Both SmartClient and Smart GWT come in three editions:
- LGPL Edition
Best for: Open source projects & hobbyists License: LGPLv3 open source license (free for commercial and non-commercial development and deployment)
- Professional Edition
Best for: Professional developers building simpler workgroup applications, and micro-ISVs License: Per-developer, with unlimited deployment
- Power Edition
Best for: Highly skilled teams able to take advantage of advanced productivity features License: Per-developer, with unlimited deployment
- Enterprise Edition
Best for: Complex, mission-critical or enterprise-wide applications, and enterprise ISVs License: Either per-developer with unlimited deployment, or per-CPU or flat rate
Using LGPL Edition now? Find out about the benefits of upgrading - you can add major new features without reworking your existing code.
Want to see how SmartClient stacks up with competing technologies?
In the Feature Comparison below, click on feature names for a quick description and links to live examples and documentation.
|Grids, Trees, Tiles|
|Layouts, Windows, Sections, Tabs|
|Forms & Form Controls|
|Buttons, Menus & Dialogs|
|Pluggable Data Model|
|Drag and Drop|
|Client-side DataSource & Data binding|
|REST / WSDL support|
|Skinning / Branding|
|Server Data Binding||—|
(SQL, JPA & Hibernate)
|Reify Mockup Importer||—|
|File Upload &
(SQL, JPA & Hibernate)
|SQL / HQL Templating||—||—|
|Network Performance Module||—||—|
|OLAP / Datacube support
|Real-time Messaging Module||—||—||(Optional)||(Optional)|
|Batch DataSource Generator||—||—||—|
|Visual Builder Team License||—||—||—|
|Portal Framework (Preview)||—||—||—|
|Visual Builder OEM License||—||—||—||(Optional)|
$745 per developer
(less in bulk)
$1950 per developer
(less in bulk)
Choose: Per Developer
or Per CPU
or Flat Rate
60 day trial
Download Trial Now
For more information on licensing options, see the Product & Licensing FAQ.
Feature Descriptions (and samples)
The following brief feature descriptions describe the features in the table above, and provide links to live examples and documentation.
Client Features (Summary): SmartClient LGPL and Smart GWT include all in-browser components, including all UI components and all client-side databinding systems, with the sole exception of the UI components involved in the Analytics module (CubeGrid and Chart) and communications code designed specifically for interactions with the SmartClient Server Framework. A complete system ready for binding with any REST or WSDL services or with GWT-RPC.
Server Features (Summary): Server features are based on the SmartClient Java Server Framework, a set of standard Java .jars, servlets, jsp tags, tools and other resources that work with any standard J2SE or J2EE servlet engine or application server and with any standard Java IDE. The SmartClient Server Framework can be installed into existing projects and is compatible with popular Java frameworks such as Struts or Spring.
Adaptive Filter & Sort: Combines large dataset handling with adaptive use of client-side filtering and sorting: to handle datasets that are too large to download completely in advance, filtering and sorting initially take place on the server. When all matching records have been loaded client-side, SmartClient automatically & transparently switches to client-side filtering and sorting. This provides immediate responsiveness and dramatically reduced server load. Works with any server platform; Java Servers with SmartClient Pro or better have built-in support for server-side filtering for SQL, JPA, and Hibernate. (Adaptive Filtering examples: SmartClient; SmartGWT. Adaptive Sort examples: SmartClient; SmartGWT.)
Pluggable Data Model: UI components support a "pluggable" data model that provides both a description of the data (fields, types, validation rules, etc) and operations to fetch and modify data. This "pluggable" data model approach means user interfaces can be re-used with any data provider without change. Screen designs such as master-detail navigation can be easily captured as custom components that are then usable with any data model — you can even swap the data model on the fly. (Examples: SmartClient; SmartGWT.)
Server Data Binding: Provides a simple Java API for handling requests for data from SmartClient visual components. Greatly accelerates integration with Java-based servers as compared to building REST or WSDL services for SmartClient components to consume. Client-to-server communications are handled automatically and transparently via a high speed, compressed protocol. Sophisticated client-server protocol handles data paging, server-side sort, automatic cache updates, validation and other error handling, optimistic concurrency (aka long transactions) and binary file uploads. Requests can be routed to Java classes via simple XML declarations, and required parameters to the method are fulfilled automatically, similar to Spring's "dependency injection". (SmartClient custom DataSource example here. DMI examples: SmartClient; SmartGWT.)
Server-side Validation: Both client and server validation are driven from a single XML declaration, with a built-in set of validators similar to XML Schema or JPA restrictions. (Examples: SmartClient; SmartGWT.) Custom client and server-side validators can be added, and a powerful expression language can turn complex cross-object validations into one-line declarations. (Examples: SmartClient; SmartGWT.) Server contact is automatically managed for validators that require it. (Examples: SmartClient; SmartGWT.)
UI Generation: Automatic generation of grid, form, detail and tiled views from Java Beans or SQL tables. Unlike "scaffolding" approaches that leave you maintaining generated code, generation is dynamic, and you can customize any detail of the generated components without losing automatic generation. Without this capability, every screen of your application duplicates the information you already have in your server data model, leading to highly redundant, brittle applications. See the QuickStart Guide, Server Framework Chapter, first section.
Declarative Security: Attach role-based security declaratively to DataSource operations. UI components are security-aware and automatically disable UI for disallowed functions. Zero code integration with J2EE Security, Spring Security, or JAAS. Documentation can be found here and here. Also available as a preview for Enterprise Edition is a pre-built login process and user administration interface. To begin using this functionality now, take advantage of the Jump Start program to receive training and starter code.
Excel Export: Allows any grid component to export its current dataset as an Excel spreadsheet or CSV file without the need to write any server code. Exported data respects the user's current column order, sort direction, search criteria, and shown vs. hidden fields. Excel spreadsheets include correct data types (numbers, dates) and custom data hiliting rules. Works with any DataSource type — SQL, JPA, Hibernate, or custom. (Examples: SmartClient; SmartGWT.)
Basic Connectors (SQL, JPA & Hibernate): A one-line declaration enables all CRUD operations (create, retrieve, update, delete) against any SQL table, SQL View, JPA entity or Hibernate entity. No server code is required. Java business logic may be added to modify requests before they are executed by the connector, modify responses, or take any other action. For an overview, see the QuickStart Guide, Server Framework Chapter. Note: Basic connectors enable query-by-example search; for Advanced Search, purchase Power Edition or better.
- Hibernate Connector in action: SmartClient, SmartGWT examples.
- Auto-derived DataSources in SmartClient: Hibernate and JPA examples.
- Auto-derived DataSources in Smart GWT EE: Hibernate and JPA examples.
Queuing: Queuing allows multiple data load or save requests from different UI components to be transparently combined into a single HTTP request with guaranteed in-order execution. Queuing makes it easy to reuse data operations across different screens and in different combinations without needing to write screen-specific code to combine operations together. Queuing also makes it simple to define transaction boundaries when data in different UI components need to be saved together. (Examples: SmartClient; SmartGWT.)
"Reify" Mockup Importer: Reify takes mockups from Balsamiq and turns them into working screens backed by clean, clear code that is easy to extend and customize. Instead of having developers painstakingly re-create the layout shown in a mockup, just use Reify to import it - a much more efficient development process. Learn more..
UI Auto-mapping: Intelligent 2-way binding between persistent Java objects and UI components handles arbitrarily nested objects, Java Enums and Generics, avoids transmitting unused data to the browser without the need to write separate DTOs (Data Transfer Objects), and even allows bi-directional XPath-based mapping between UI fields and Java objects, when loading and saving data. (Data Selection example: SmartClient; SmartGWT. Saving nested objects example: SmartClient; SmartGWT.)
File Upload & Binary Storage: Single and multiple file uploads can be handled as normal DataSource operation, including normal handling of validation errors. Optional automatic storage to SQL (no server code required). (example)
HTTP Proxying: The HTTP Proxy allows an application to access to web services hosted on remote servers, which are normally inaccessible to web applications due to the same origin policy. Once installed, the HTTP Proxy provides transparent proxying of requests without further configuration; public sites may wish to whitelist specific services that may be accessed via proxy, for security reasons. (Examples: SmartClient; SmartGWT.)
Visual Builder: A drag and drop screen design tool that allows codeless creation of applications, complete with event handling and data connectivity. Learn more..
HTML5 Charts: Get high-quality charts pre-integrated with Smart GWT components. Our HTML5-based charting engine works in all supported browsers, including Internet Explorer and mobile browsers, with no plug-ins required and no requirement to write browser-specific code. (Examples: SmartClient; SmartGWT.) Note: in Smart GWT 2.5, the HTML5 Charts feature required Power Edition + Analytics. In Smart GWT 3.0, only Pro Edition is required.
Advanced Search: Complex searches assembled via the FilterBuilder component can be executed against SQL, JPA, or Hibernate without the need to write any code. (SmartClient example) (Smart GWT example)
SQL/HQL Templating: Allows the SQL or HQL queries automatically generated by the SQL and Hibernate connectors to be easily customized directly in the DataSource definition, by overriding specific clauses from the automatically generated query, without the need to write Java code. SQL Templating makes it trivial to use SQL joins while retaining built-in features like advanced search (SmartClient, SmartGWT examples). Even complex reporting queries can still leverage search, data paging, and other built-in features (SmartClient, SmartGWT examples).
Automatic Transactions: When using SQL and Hibernate connectors, any batch of save operations submitted to the server is automatically combined into a database transaction. Since UI interactions such as Mass Update and Multi-Row Drag and Drop automatically submit a batch of save operations to the server, these and many other UI operations are automatically transactional in Power Edition and above.
Batch Uploader: An end user interface for batch upload of data as a pre-built, customizable component. User can upload data, have it validated, make corrections, and save the data to a target DataSource. Supports a variety of upload formats and any data store that can be connected to SmartClient. (Examples: SmartClient; SmartGWT.)
- Background download of the SmartClient runtime and application resources while users are interacting with a login/registration page, splash screen or other non-SmartClient content
- Automatic compressed delivery of all of compressible content, including browser-specific workarounds where required.
Analytics Module: Specialized components for viewing, navigating and editing very large, multi-dimensional data sets (also known as data cubes) for business intelligence, analytics and reporting applications. (Basic CubeGrid samples: SmartClient, SmartGWT. CubeGrid samples with load on demand and charting: SmartClient, SmartGWT.)
Real-time Messaging Module: Real-time data delivery via HTTP streaming (aka "Comet") for monitoring, command & control, trading desk and real-time collaboration applications involving time-sensitive, continuously updated data. SmartClient Messaging supports data delivery rates sufficient for continuous full-screen refresh and works through firewalls, HTTP proxies and other intervening network devices that can cause issues with other HTTP Streaming / Comet implementations. Supports codeless integration with JMS (Java Message Service) and a custom connector architecture for other message sources. (Examples: SmartClient; SmartGWT.)
Optional Modules: (Optional) features are available for purchase at an additional cost. The Analytics Module and Real-Time Messaging Module are only available as paid additions to Power and above licenses and cost $500 each per developer.
Indemnity, Warranty, custom terms: (Not strictly a feature) Enterprise licenses come with the legal protections typically required by large enterprises for risk management reasons. Exact terms can be modified to suit your organization's legal requirements.
Batch DataSource Generator: A supported tool, with source code included, that can produce SmartClient DataSource definitions automatically from database metadata, Hibernate mappings and Javabeans. This tool uses the same technology as the SQL Wizard and Hibernate Wizard, and is specifically designed to be easily extensible to suit your own needs.
Visual Builder Team License: Allows use of Visual Builder within an organization as a central design and development hub on a shared server, where users can collaborate on a shared design by simply emailing a URL. Visual Builder eliminates waste and duplication in the design process: instead of the throw-away "wireframes" produced by typical design tools, prototypes built in Visual Builder are real applications, ready to deploy or to customize further inside traditional development tools. Learn more..
Portal Framework (Preview): User-reconfigurable portal-style layouts with automatic persistence of layout and portlet state, including filtering rules, hilighting rules and user-defined formula columns for grid-based portlets. Place anything in a Portlet via pluggable portlet API. Users can easily share saved layouts with team members. Ideal for lightweight BI (Business Intelligence) and other RIA portal applications. Already deployed at Isomorphic customers. To begin using this functionality now, take advantage of the Jump Start program to receive training and starter code. (SmartClient Example.)
Visual Builder OEM License: Allows a software
vendor to ship Visual Builder or parts of Visual Builder as a customization interface for a
SmartClient-based product. The underlying components of Visual Builder can be quickly
assembled into a variety of customization interfaces that allow your customers to edit specific
properties or specific areas of your application. SmartClient branding, terminology and
documentation can be suppressed or replaced so that you can deliver tools that seamlessly
fit your application and use terminology familiar to your users.
Visual Builder OEM is only available as a paid addition to Enterprise licenses, and requires
collaboration with Isomorphic. Please contact sales to get started.