Showing papers on "Java applet published in 2009"

Jalview Version 2--a multiple sequence alignment editor and analysis workbench.

Abstract: Summary: Jalview Version 2 is a system for interactive WYSIWYG editing, analysis and annotation of multiple sequence alignments. Core features include keyboard and mouse-based editing, multiple views and alignment overviews, and linked structure display with Jmol. Jalview 2 is available in two forms: a lightweight Java applet for use in web applications, and a powerful desktop application that employs web services for sequence alignment, secondary structure prediction and the retrieval of alignments, sequences, annotation and structures from public databases and any DAS 1.53 compliant sequence or annotation server. Availability: The Jalview 2 Desktop application and JalviewLite applet are made freely available under the GPL, and can be downloaded from www.jalview.org Contact: g.j.barton@dundee.ac.uk

Anonymous credentials on a standard java card

Abstract: Secure identity tokens such as Electronic Identity (eID) cards are emerging everywhere. At the same time user-centric identity management gains acceptance. Anonymous credential schemes are the optimal realization of user-centricity. However, on inexpensive hardware platforms, typically used for eID cards, these schemes could not be made to meet the necessary requirements such as future-proof key lengths and transaction times on the order of 10 seconds. The reasons for this is the need for the hardware platform to be standardized and certified. Therefore an implementation is only possible as a Java Card applet. This results in severe restrictions: little memory (transient and persistent), an 8-bit CPU, and access to hardware acceleration for cryptographic operations only by defined interfaces such as RSA encryption operations.Still, we present the first practical implementation of an anonymous credential system on a Java Card 2.2.1. We achieve transaction times that are orders of magnitudes faster than those of any prior attempt, while raising the bar in terms of key length and trust model. Our system is the first one to act completely autonomously on card and to maintain its properties in the face of an untrusted terminal. In addition, we provide a formal system specification and share our solution strategies and experiences gained and with the Java Card.

Real-time collaboration of virtual laboratories through the Internet

Abstract: Web-based learning environments are becoming increasingly popular in higher education. One of the most important web-learning resources is the virtual laboratory (VL), which gives students an easy way for training and learning through the Internet. Moreover, on-line collaborative communication represents a practical method to transmit the knowledge and experience from the teacher to students overcoming physical distance and isolation. Considering these facts, the authors of this document have developed a new dynamic collaborative e-learning system which combines the main advantages of virtual laboratories and collaborative learning practices. In this system, the virtual laboratories are based on Java applets which have embedded simulations developed in Easy Java Simulations (EJS), an open-source tool for teachers who do not need complex programming skills. The collaborative e-learning is based on a real-time synchronized communication among these Java applets. Therefore, this original approach provides a new tool which integrates virtual laboratories inside a synchronous collaborative e-learning framework. This paper describes the main features of this system and its successful application in a distance education environment among different universities from Spain.

J-Orchestra: Enhancing Java programs with distribution capabilities

Abstract: J-Orchestra is a system that enhances centralized Java programs with distribution capabilities. Operating at the bytecode level, J-Orchestra transforms a centralized Java program (i.e., running on a single Java Virtual Machine (JVM)) into a distributed one (i.e., running across multiple JVMs). This transformation effectively separates distribution concerns from the core functionality of a program. J-Orchestra follows a semiautomatic transformation process. Through a GUI, the user selects program elements (at class granularity) and assigns them to network locations. Based on the user's input, the J-Orchestra backend automatically partitions the program through compiler-level techniques, without changes to the JVM or to the Java Runtime Environment (JRE) classes. By means of bytecode engineering and code generation, J-Orchestra substitutes method calls with remote method calls, direct object references with proxy references, etc. It also translates Java language features (e.g., static methods and fields, inheritance, inner classes, new object construction, etc.) for efficient distributed execution.We detail the main technical issues that J-Orchestra addresses, including its mechanism for program transformation in the presence of unmodifiable code (e.g., in JRE classes) and the translation of concurrency and synchronization constructs to work correctly over the network. We further discuss a case study of transforming a large, commercial, third-party application for efficient execution in a client server environment and outline the architectural characteristics of centralized programs that are amenable to automated distribution with J-Orchestra.

The PubChem chemical structure sketcher

Abstract: PubChem is an important public, Web-based information source for chemical and bioactivity information. In order to provide convenient structure search methods on compounds stored in this database, one mandatory component is a Web-based drawing tool for interactive sketching of chemical query structures. Web-enabled chemical structure sketchers are not new, being in existence for years; however, solutions available rely on complex technology like Java applets or platform-dependent plug-ins. Due to general policy and support incident rate considerations, Java-based or platform-specific sketchers cannot be deployed as a part of public NCBI Web services. Our solution: a chemical structure sketching tool based exclusively on CGI server processing, client-side JavaScript functions, and image sequence streaming. The PubChem structure editor does not require the presence of any specific runtime support libraries or browser configurations on the client. It is completely platform-independent and verified to work on all major Web browsers, including older ones without support for Web2.0 JavaScript objects.

Efficient character-level taint tracking for Java

Abstract: Over 80% of web services are vulnerable to attack, and much of the danger arises from command injection vulnerabilities. We present an efficient character-level taint tracking system for Java web applications and argue that it can be used to defend against command injection vulnerabilities. Our approach involves modification only to Java library classes and the implementation of the Java servlets framework, so it requires only a one-time modification to the server without any subsequent modifications to a web application's bytecode or access to the web application's source code. This makes it easy to deploy our technique and easy to secure legacy web software. Our preliminary experiments with the JForum web application suggest that character-level taint tracking adds 0-15% runtime overhead.

Real time Java on resource-constrained platforms with Fiji VM

Abstract: Real-time Java is quickly emerging as a platform for building safety-critical embedded systems. The real-time variants of Java, including [8, 15], are attractive alternatives to Ada and C since they provide a cleaner, simpler, and safer programming model. Unfortunately, current real-time Java implementations have trouble scaling down to very hard real-time embedded settings, where memory is scarce and processing power is limited. In this paper, we describe the architecture of the Fiji VM, which enables vanilla Java applications to run in very hard environments, including booting on bare hardware with only very rudimentary operating system support. We also show that our minimalistic approach delivers comparable performance to that of server-class production Java Virtual Machine implementations.

Finding bugs in exceptional situations of JNI programs

Abstract: Software flaws in native methods may defeat Java's guarantees of safety and security. One common kind of flaws in native methods results from the discrepancy on how exceptions are handled in Java and in native methods. Unlike exceptions in Java, exceptions raised in the native code through the Java Native Interface (JNI) are not controlled by the Java Virtual Machine (JVM). Only after the native code finishes execution will the JVM's mechanism for exceptions take over. This discrepancy makes handling of JNI exceptions an error prone process and can cause serious security flaws in software written using the JNI.We propose a novel static analysis framework to examine exceptions and report errors in JNI programs. We have built a complete tool consisting of exception analysis, static taint analysis, and warning recovery. Experimental results demonstrated this tool allows finding of mishandling of exceptions with high accuracy (15.4% false-positive rate on over 260k lines of code). Our framework can be easily applied to analyzing software written in other foreign function interfaces, including the Python/C interface and the OCaml/C interface.

RESTful Java with JAX-RS

Abstract: Learn how to design and develop distributed web services in Java using RESTful architectural principals and the JAX-RS specification in Java EE 6. With this hands-on reference, you'll focus on implementation rather than theory, and discover why the RESTful method is far better than technologies like CORBA and SOAP. It's easy to get started with services based on the REST architecture. RESTful Java with JAX-RS includes a technical guide that explains REST and JAX-RS, how they work, and when to use them. With the RESTEasy workbook that follows, you get step-by-step instructions for installing, configuring, and running several working JAX-RS examples using the JBoss RESTEasy implementation of JAX-RS. Work on the design of a distributed RESTful interface, and develop it in Java as a JAX-RS service Dispatch HTTP requests in JAX-RS, and learn how to extract information from them Deploy your web services within Java Enterprise Edition using the Application class, Default Component Model, EJB Integration, Spring Integration, and JPA Discover several options for securing your web services Learn how to implement RESTful design patterns using JAX-RS Write RESTful clients in Java using libraries and frameworks such as java.net.URL, Apache HTTP Client, and RESTEasy Proxy

Java Web Services: Up and Running

Abstract: QA Java provides such coverage with rich options for programming and publishing web services. Web services come in two major flavors, REST-style and SOAP-based, and Java has excellent support for each flavoron the service and the client side. The book emphasizes code, on both the service and the client side. Accordingly, there are various full-code examples, on the service side, for all of popular Java APIs for doing REST-style and SOAP-based web services: HttpServlet, JAX-RS, Restlet, JAX-WS. There are also extensive examples on the client side, including clients against popular real-world services such as those from Amazon and Twitter. The book includes a full chapter on wire-level and users/roles security. Q. What's the most exciting and important thing happening in this Java web services? A. The distinction between traditional HTML-based websites and web services continues to blur. For one thing, modern websites typically contain JavaScript (in one dialect or another) embedded within the HTML; and embedded JavaScript is increasingly used to write clients against web services. Q. Can you give us a few tips when getting started with Java Web Services? A. 1. Traditional programming skills used to create Java-based websites using the JSP/ HttpServlet APIs transfer nicely to REST-style web services. The publication of a Java-based web service is essentially the same as that for a Java-based website (for example, a web server such as Tomcat or Jetty can be used for either). 2. Despite the growing popularity of REST-style services, SOAP-based services delivered over HTTP/HTTPS remain a programmer-friendly variant of REST-style services; and SOAP-based clients are typically easier to write than REST-style ones. 3. Programming a web service and then publishing it are nicely separated concerns: In general, how the service is programmed (for instance, the APIs used) has little or no impact on how the service is published (for instance, with a command-line publisher, a commercial-grade web server such as Tomcat, or a full-blown Java Application Server such as GlassFish or JBoss). 4. jQuery and other JavaScript dialects make it increasingly easy to embed web-service clients within HTML pages. 5. Securing a web service is essentially the same as securing a web site.

The Spectral Game: leveraging Open Data and crowdsourcing for education

Abstract: We report on the implementation of the Spectral Game, a web-based game where players try to match molecules to various forms of interactive spectra including 1D/2D NMR, Mass Spectrometry and Infrared spectra. Each correct selection earns the player one point and play continues until the player supplies an incorrect answer. The game is usually played using a web browser interface, although a version has been developed in the virtual 3D environment of Second Life. Spectra uploaded as Open Data to ChemSpider in JCAMP-DX format are used for the problem sets together with structures extracted from the website. The spectra are displayed using JSpecView, an Open Source spectrum viewing applet which affords zooming and integration. The application of the game to the teaching of proton NMR spectroscopy in an undergraduate organic chemistry class and a 2D Spectrum Viewer are also presented.

Loci: Simple Thread-Locality for Java

Abstract: This paper presents a simple type system for thread-local data in Java. Classes and types are annotated to express thread-locality and unintended leaks are detected at compile-time. The system, called Loci, is minimal, modular and compatible with legacy code. The only change to the language is the addition of two new metadata annotations. We implemented Loci as an Eclipse plug-in and used it to evaluate our design on a number of benchmarks. We found that Loci is compatible with how Java programs are written and that the annotation overhead is light thanks to a judicious choice of defaults.

Real-Time Java Programming: With Java RTS

Abstract: The Definitive Guide to Java RTS for Developers and Architects For Java developers and architects moving to real-time, and real-time developers moving to Java Walks through start-to-finish case study applications, identifying their constraints and discussing the APIs and design patterns used to address them Written by the former leader of the real-time Java standards process and one of Wall Streets top real-time developers Sun Microsystems Java Real-Time System (Java RTS) is proving itself in numerous, wide-ranging environments, including finance, control systems, manufacturing, and defense. Java RTS and the RTSJ standard (JSR-001) eliminate the need for complicated, specialized, real-time languages and operating environments, saving money by leveraging Javas exceptional productivity and familiarity. In Real-Time Java Programming, two of Suns top real-time programming experts present the deep knowledge and realistic code examples that developers need to succeed with Java RTS and its APIs. As they do so, the authors also illuminate the foundations of real-time programming in any RTSJ-compatible environment. Key topics include Real-time principles and concepts, and the unique requirements of real-time application design and development How Java has been adapted to real-time environments A complete chapter on garbage collection concepts and Java SE collectors Using the Java RTS APIs to solve actual real-time system problems as efficiently as possible Utilizing todays leading Java RTS development and debugging tools Understanding real-time garbage collection, threads, scheduling, and dispatching Programming new RTSJ memory models Dealing with asynchronous event handling and asynchronous transfer of control

Genetic programming in the wild: evolving unrestricted bytecode

Abstract: We describe a methodology for evolving Java bytecode, enabling the evolution of extant, unrestricted Java programs, or programs in other languages that compile to Java bytecode. Bytecode is evolved directly, without any intermediate genomic representation. Our approach is based upon the notion of compatible crossover, which produces correct programs by performing operand stack-, local variables-, and control flow-based compatibility checks on source and destination bytecode sections. This is in contrast to existing work that uses restricted subsets of the Java bytecode instruction set as a representation language for individuals in genetic programming. Given the huge universe of unrestricted Java bytecode, as is programs, our work enables the applications of evolution within this realm. We experimentally validate our methodology by both extensively testing the correctness of compatible crossover on arbitrary bytecode, and by running evolution on a program that exploits the richness of the Java virtual machine architecture and type system.

Method and apparatus for interacting with media programming in real-time using a mobile telephone device

Abstract: A system and method for providing real-time interaction with a multimedia program being presented to a viewer having an interactive end-user communications device. The system and method includes an applet distribution program to provide an applet to the interactive end-user communications device, where the applet includes a timer, time stamps and at least one interactive graphical user interface (GUI). The applet distribution program is operable to synchronize activation of the applet with the multimedia program while being presented to the viewer, wherein the applet generates, at a first predetermined time, a first interactive graphical user interface (GUI) on the end-user communications device, the first GUI displaying at least two values associated with the multimedia program for real-time selection by the viewer. A response signal is received from the end-user communications device when a predetermined metric associated with correct selections of the at least two values by the viewer is satisfied.

From Remote Experiments to Web-Based Learning Objects: An Advanced Telelaboratory for Robotics and Control Systems

Abstract: This paper describes the current evolution of the telelaboratory facilities at the University of Pisa. In particular, starting from a standard environment providing remote access to a set of experiments, the telelaboratory is now organized as a collection of learning objects, i.e., modular didactic units designed following specific learning objectives within control systems and robotic fields. The telelaboratory has a remote Web-based access which can be used both as a simulation environment and as a remote way of performing real physical experiments. The developed telelaboratory is based on free open-source software such as Scilab/Scicos, Comedi, and real-time application interface patch for Linux kernels. In-house software tools, such as a Java Web hyper modular interface system, graphic environment tools, and a virtual laboratory interface based on Java applets, have been developed as a support for the learning process.

GenWrapper: A generic wrapper for running legacy applications on desktop grids

Abstract: Desktop Grids represent an alternative trend in Grid computing using the same software infrastructure as Volunteer Computing projects, such as BOINC. Applications to be deployed on a BOINC infrastructure need special preparations. However, there are many legacy applications, that have either no source code available or would require too much effort to port. For these applications BOINC provides a wrapper. This wrapper can handle the simple cases and it is configurable, but it can only be used to execute a list of legacy executables (tasks) one after the other. GenWrapper aims to provide a generic solution for wrapping and executing an arbitrary set of legacy applications by utilizing a POSIX like shell scripting environment to describe how the application is to be run and how the work unit should be processed. This is realized by an extended version of BusyBox providing the most common UNIX commands and a POSIX shell interpreter in a single executable with a special applet (BusyBox extension) to make BOINC API functions accessible from the shell on Windows, Linux and Mac OS X platforms. In this paper we present how GenWrapper works and how it can be used to port legacy applications to Desktop Grid systems.

Computer program code and method for delivering external data to a process running on a virtual machine

Abstract: A method and system for delivering external data to a process running on a virtual machine, the virtual machine running on an operating system. The method includes the steps of executing instructions on the virtual machine that obtain state data related to the process; querying the virtual machine to obtain component data related to the state data; and manipulating the component data to deliver the external data to the process. In one example, the system provides a single sign-on application that passes user credentials to a Java applet running on a Java virtual machine.

Lazy continuations for Java virtual machines

Abstract: Continuations, or 'the rest of the computation', are a concept that is most often used in the context of functional and dynamic programming languages. Implementations of such languages that work on top of the Java virtual machine (JVM) have traditionally been complicated by the lack of continuations because they must be simulated.We propose an implementation of continuations in the Java virtual machine with a lazy or on-demand approach. Our system imposes zero run-time overhead as long as no activations need to be saved and restored and performs well when continuations are used. Although our implementation can be used from Java code directly, it is mainly intended to facilitate the creation of frameworks that allow other functional or dynamic languages to be executed on a Java virtual machine.As there are no widely used benchmarks for continuation functionality on JVMs, we developed synthetical benchmarks that show the expected costs of the most important operations depending on various parameters.

Application partitioning across a virtualized environment

Abstract: A processor including an execution core for executing instructions. In one embodiment, the instructions cause the core to enable two or more virtual machine guests to execute under the control of a virtual machine monitor. A first virtual machine guest includes a first portion of an application executing in the context of a first guest operating system. The first portion of the application creates a guest virtual machine applet that executes in the context of a second virtual machine guest. The first portion of the application and the guest virtual machine applet are part of a single application. To create a guest virtual machine applet, the first portion of the application executes a call to the first guest operating system and in response to receiving the call from the first portion of the application, the first guest operating system makes a system call to the virtual machine monitor.

The organic builder: A public experiment in artificial chemistries and self-replication

Abstract: We describe some results submitted by users of the Organic Builder, a Java applet where the rules of an artificial chemistry can be chosen in order to achieve a desired behavior. Though it was initially intended as a set of challenges to be tackled as a game, the users experimented with the system far beyond this and discovered several novel forms of self-replicators. When searching for a system with certain properties such as self-replication, making the system accessible to the public through a Web site is an unusual but effective way of making scientific discoveries, credit for which must go to the users themselves for their tireless experimentation and innovation.

Law of Large Numbers: The Theory, Applications and Technology-Based Education

Abstract: Modern approaches for technology-based blended education utilize a variety of recently developed novel pedagogical, computational and network resources. Such attempts employ technology to deliver integrated, dynamically-linked, interactive-content and heterogeneous learning environments, which may improve student comprehension and information retention. In this paper, we describe one such innovative effort of using technological tools to expose students in probability and statistics courses to the theory, practice and usability of the Law of Large Numbers (LLN). We base our approach on integrating pedagogical instruments with the computational libraries developed by the Statistics Online Computational Resource (www.SOCR.ucla.edu). To achieve this merger we designed a new interactive Java applet and a corresponding demonstration activity that illustrate the concept and the applications of the LLN. The LLN applet and activity have common goals – to provide graphical representation of the LLN principle, build lasting student intuition and present the common misconceptions about the law of large numbers. Both the SOCR LLN applet and activity are freely available online to the community to test, validate and extend (Applet: http://socr.ucla.edu/htmls/exp/Coin_Toss_LLN_Experiment.html, and Activity: http://wiki.stat.ucla.edu/socr/index.php/SOCR_EduMaterials_Activities_LLN).

Software development environment

Abstract: A system comprising: a server; a computer terminal coupled remotely to the server via a network and installed with a web browser; and an external test platform, connected externally to the computer terminal, the test platform comprising a programmable target device and interface circuitry operable to communicate between the computer terminal and the target device. The server hosts a development tool available for download to the web browser via the network. The development tool comprises: one or more applets to be run by the web browser, and one or more web pages for display by the web browser to provide a user-interface for the development tool including to provide access to the one or more applets. The one or more applets at least comprise code- analysis applet software programmed so as when run by the web browser to operate said interface circuitry to: load code to be tested from the computer terminal onto the target device for test operation.

Towards a dynamic-update-enabled JVM

Abstract: This paper advocates that de facto dynamic updates of Java applications will eventually require a dynamic-update-enabled Java virtual machine. We argue that our approach for dynamic updates of component-based Java applications complements the new module system planned for upcoming Java releases. We conclude that simple extensions to an existing JVM can bring full flexibility and transparency to dynamic updates in Java.

System and method for installing smart card applet

Abstract: Disclosed are a system and a method for installing a smart card applet. A response message for an OTA message received from an external remote server is transmitted to form a communication channel based on HTTP (hyper text transfer protocol) between a smart card and the remote server. The applet is installed based on applet installation information received through the communication channel. A large scale applet is installed in a card within a short period of time.

Enhanced development tool for utilizing a javascript object notation (json) bridge for non-java-based component communication within java-based composite applications

Abstract: Utilizing a JAVASCRIPT Object Notation (JSON) bridge during JAVA-based composite application development can begin with the receipt of a command to present the wiring diagram of a JAVA-based composite application by an enhanced JAVA-based composite application development tool. The JAVA-based composite application can consist of one or more JAVA-based components and non-JAVA-based components, with one property of a JAVA-based component being communicatively wired to a non-JAVA-based component. A JSON bridge can acknowledge the accessing of the JAVA-based composite application. The wiring diagram of the JAVA-based composite application can then be visually rendered. For the property of the JAVA-based component communicatively wired to the non-JAVA-based component, a user-selectable option to utilize the JSON bridge for communication can be presented. With the JSON bridge option selected, user-entered changes to this property can automatically invoke the JSON bridge to communicate related data to the communicatively wired non-JAVA-based component.

Browser-Based Enforcement of Interface Contracts in Web Applications with BeepBeep

Abstract: BeepBeep is a lightweight runtime monitor for Ajax web applications. Interface specifications are expressed internally in an extension of LTL with first-order quantification; they can be transparently enforced on the client side using a small and invisible Java applet. Violations of the specification are reported on-the-fly and prevent erroneous or out-of-sequence XML messages from reaching the server.

Beginning Java EE 6 Platform with GlassFish 3: From Novice to Professional

Abstract: Sun's enterprise Java platform, Java EE (Enterprise Edition), is getting a facelift! Beginning Java EE 6 Platform with GlassFish 3 is one of the first tutorial books on the forthcoming Java EE 6 Platform. Stepbystep and easy to follow, this book describes many of the Java EE 6 specifications and reference implementations and shows them in action using practical examples. This book uses the new version of GlassFish 3 to deploy and administer the code examples. Written by an expert member of the Java EE 6 specification request and review board in the Java Community Process (JCP), this book contains the best information possible, from an expert's perspective in enterprise Java technologies and platform. What youll learn Get started with the new Java EE 6 Platform from Sun. Explore and use the new EJB 3.1 and JPA 2.0 APIs from entities to session beans to messagedriven beans, and more. Discover the new webtier development APIs including JSPs, JSTL, and Expression Language, and especially the new JSF 2.0 and Facelets. Uncover the new web services, RESTful services, and more available in Java EE 6. Create dynamic user interfaces for your enterprise and transactional Java applications. And more... Who is this book for? This book is suitable for advanced Java programmers as well as Java EE 6 beginners. Architects will also find information about how to layer their Java EE applications. About the Apress Beginning Series The Beginning series from Apress is the right choice to get the information you need to land that crucial entrylevel job. These books will teach you a standard and important technology from the ground up because they are explicitly designed to take you from novice to professional. Youll start your journey by seeing what you need to knowbut without needless theory and filler. Youll build your skill set by learning how to put together realworld projects step by step. So whether your goal is your next career challenge or a new learning opportunity, the Beginning series from Apress will take you thereit is your trusted guide through unfamiliar territory!

MoonWalker: Verification of .NET Programs

Abstract: MoonWalker is a software model checker for cil bytecode programs, which is able to detect deadlocks and assertion violations in cil assemblies, better known as Microsoft .NET programs. The design of MoonWalker is inspired by the Java PathFinder ( jpf ), a model checker for Java programs. The performance of MoonWalker is on par with jpf . This paper presents the new version of MoonWalker and discusses its most important features.

3D Java web-based games development and deployment

Abstract: Currently, web-based online gaming applications are predominately utilising Adobe Flash or Java Applets as their core technologies. These games are often casual, two-dimensional games and do not utilise the specialist graphics hardware which has proliferated across modern PCs and Consoles. Multi-user online game play in these titles is often either non-existent or extremely limited. Computer games applications which grace the current generation of consoles and personal computers are designed to utilise the increasingly impressive hardware power at their disposal. However, these are commonly distributed using a physical medium or deployed through custom, proprietary networking mechanisms and rely upon platform-specific networking APIs to facilitate multi-user online game play. In order to unify the concepts of these disparate styles of gaming, in this paper we propose a novel integrated development environment called Homura and NetHomura. Homura is based on the Eclipse platform and extends the jME game engine, with new interfaces, content and libraries, thus, providing a software suite that integrates source editors, compilers, including spatial and positional editors to afford advanced graphical functionalities within the IDE. We also present two interconnected systems which are implemented using Java Web Start and JXTA P2P technologies, providing a platform-independent framework capable of deploying hardware accelerated cross-platform, cross-browser online-enabled Java games, as part of the NetHomura Project.