Sweet is a web application framework for building dynamic web content that runs on any Java servlet server. The framework is made with Scala, a more advance and easier to write programming language compared to Java. Since Sweet applications can run on a Java Virtual Machine, it can take advantage of all the Java libraries, servers, and large communities.
Our visions and goals for Sweet is SWEET itself:
* Simplicity - Sweet needs to keep complex things simple.
* Works - Sweet needs to be practical and functional.
* Efficient - Sweet needs to be efficient.
* Extensible - Sweet needs to be extensible by developers.
* Testable - Sweet needs to be testable.
Vaadin is a Java web application framework. It is designed for creating rich and interactive applications that run in the browser, without any plugins. A server-driven architecture together with reusable component model is used to simplify programming of applications and for better web application security. No HTML, XML or JavaScript necessary and all Java libraries and tools are at your disposal.
Hannibal is a code generator that can generate scaffolding for web projects in different languages, including Java, PHP, SQL, and JavaScript. The code it generates follows Restful considerations.
[fleXive] is a JavaEE 5 open source (LGPL 2.1 or higher) framework for the development of complex and evolving (web-)applications. It speeds up development by easing many tedious and repetitive programming tasks and helping to keep your application(s) flexible during the development-cycle and in production.
Based on the latest industry-standards like EJB 3, JSF, etc. [fleXive] should be your choice for building up your own new application.
JSF Flex goal is to provide users capability in creating standard Flex components as JSF components. So users would create the components as normal JSF components and the project will create the necessary SWC, SWF files and etcetera and link the values of the components back to the managed beans using JSON+Javascript and Actionscript. {standard Flex components has been open sourced through MPL license}
Currently many of the standard rich flex widgets (buttons, sliders, inputs [richTextEditor, textArea, ...], progressbars, colorpickers, various panels [accordion, tabBar, ...], and etcetera) have been written as intention of support.
Exadel Fiji
Exadel Fiji is an extension to JavaServer Faces to fully encapsulate Flex.
Exadel Fiji extends JSF by allowing the use of Flex with JSF components and within a JSF page. When using Fiji Flex components, developers can use Flex with the same familiar JSF component-based approach to building user interfaces.
Welcome to Project SocialSite, an open source (CDDL/GPL2) project building Widgets and Web Services that make it easy for you to add social networking features to your existing web sites, including the ability to run OpenSocial Gadgets and have them backed by the same social graph.
Here are some of the key features we're developing:
* A complete end-to-end user interface for Social Networking in the form of JavaScript widgets that can be embedded into any site (Java, Ruby, PHP-based and more).
* A flexible Social Graph repository that can work in a wide variety of social networking scenarios. With configurable profile properties and relationship types.
* Comprehensive JavaScript and REST API access to that Social Graph repository: OpenSocial plus conforming extensions.
* Scalability via support for running in distributed configuration, table partitioning technologies, master and slave databases and distributed caching.
Gracelets is a view/controller technology layered on top of Facelets/JSF. It complements the Facelets templating technology by allowing Groovy scripts to replace or be used in connection with normal Facelets source files and views.
The name came from combining the Gr in Groovy and replacing the F in Facelets with Gr, Groovy Facelets, or Gracelets (yeah, a no-brainer).
One of the inspirations behind Gracelets was the desire to use Groovy scripts, which have many practical applications for many java developers these days, and yet have all the power of Facelets and JSF behind the groovy script. Another inspiration was to at least have the option to develop quick solutions in a single file. Of course the Model-View-Controller concept is marvillous and it is important to keep things seperate, which can also be easily done with Gracelets. But sometimes it is nice not to be forced to do so just to prototype or develop some quick solution that one wants or needs, and Gracelets gives you that option. In other words, Gracelets works fine as simply a view technology in the MVC flow, but also allows you to do more in a single script if you so desire.
The main goal of Gracelets is to complement Facelets and provide more options, flexibility and efficiency to Facelets and JSF users and component developers. Since you can still use normal Facelet XHTML views and everything else you already have invested in JSF/Facelets, you are not forced to use Gracelets even though it is installed/configured. Thus you can choose exactly where you want to use Groovy Facelets/Gracelets in your application. Even inside Gracelet scripts, you can still access the full component/tag set already available in JSF/Facelets. Some of the possible practical uses of Gracelets could be (but is not limited to) the following:
jabsorb is a simple and lightweight Ajax/Web 2.0 framework that allows you to call methods in a Java web application from JavaScript code running in a web browser as if they were local objects residing directly in the browser.
jabsorb handles all the details of marshalling and unmarshalling objects back and forth between the client and server so that you can focus on writing your application features.
jabsorb makes use of the JSON-RPC protocol for it's transport mechanism. JSON-RPC is a standard protocol and jabsorb can interoperate with other standard JSON-RPC clients and servers that may be written in other languages.
Starting with jabsorb 1.2, additional ORB functionality has been added, and it extends the basic JSON-RPC protocol to allow for passing data structures that contain Circular References.
The Riena platform will be the foundation for building multi-tier enterprise client/server applications. As such Riena will broaden the usage of the service oriented architecture of OSGi/Equinox by providing access to local and remote services in a transparent way. Using this uniform programming model, the components of Riena and the business components of the enterprise application can be developed regardless of their target location. Components are later easily placed on client or server depending on the business requirements.
As an example the Riena user interface components will support a business process oriented user interface visualization and navigation metaphor which can be used as alternative to the default workbench layout.
Ramaze is a simple, light, and modular open-source web-framework written in Ruby, similar in spirit to Rails, Camping and merb.
Ramaze is extremely stable (thanks in part to an exhaustive test suite) and currently has no known bugs.
Ramaze is usually pronounced ra-ma-ze, Japanese style.
Parancoe is a Java meta-framework aggregating in an useful way Hibernate/JPA, Spring 2, Spring MVC and, for the AJAX support, DWR. Parancoe purpose is to give to developers a set of libraries ready to build standard web applications (which in most cases are just crud applications) without worrying of long and harmful configurations files. Parancoe will be composed of a full MVC stack.
Direct Web Remoting
DWR allows Javascript in a browser to interact with Java on a server and helps you manipulate web pages with the results.
DWR is Easy Ajax for Java
Qwicket is a quickstart application for the wicket framework. Its intent is to provide a rapid method for creating a new wicket project with the basic infrastructure in place so that you can quickly get to the meat of your application rather than mucking with the plumbing of a wicket application. Currently, the system only supports spring and hibernate built with ant. Future plans include support for maven 2 and other persistence layers such as ibatis.
The Semblance project provides reusable components for Java applications. It consists of three subprojects: two are frameworks, while the third is an example application. The Foundation framework provides a set of generic utility classes and components, much of which was formerly part of the StrutsLive code base.
The StrutsLive framework builds on the capabilities provided by the Foundation Framework to provide powerful extensions to Apache Struts that make Struts development radically easier and faster. StrutsLive is in use today in numerous major production applications, from high-volume B2C websites like The Shopping Channel and Armani Exchange to mission-critical B2B applications, such as an energy trading system for Enbridge Energy, a billing system for a major European telecommunications company, and the Environmental Protection Agency's compliance reporting system.
With proper mark-up/logic separation, a POJO data model, and a refreshing lack of XML, Wicket makes developing web-apps in Java simple and enjoyable again. Swap the boilerplate, complex debugging and brittle code for powerful, reusable components written with plain Java and HTML.