SmartClient / Smart GWT vs. Competing Technologies
Cheaper
Our Free version is more comprehensive than what competitors expect you to pay for
Better
Our baseline commercial version (Pro) compares favorably to solutions that cost astronomically more
More Advanced
Our Power edition includes powerful, unique capabilities you won’t see in other products for years
| Feature | SmartClient / Smart GWT | React Mix & Match | Sencha Ext JS, GXT | Vaadin | ||
|---|---|---|---|---|---|---|
| LGPL | Pro | Power | ||||
| Client Features | ||||||
| Cohesive System | ||||||
| Basic UI Components | ||||||
| Calendar | ||||||
| Client-side Events | ||||||
| Adaptive Filtering | ||||||
| Pluggable Data Model | ||||||
| REST support | ||||||
| WSDL/XML Schema | ||||||
| Skinning / Branding | ||||||
| Printing Support | ||||||
| Advanced Filtering | ||||||
| Automated Testing | ||||||
| Low Code Hybrid Dev | ||||||
| AI Grid Features | ||||||
| AI + Low Code | ||||||
| SERVER FEATURES (Requires SmartClient / Smart GWT commercial license) | ||||||
| Server Data Binding | ||||||
| Server-side Validation | ||||||
| Declarative Security | ||||||
| UI Generation | ||||||
| UI Auto-mapping | ||||||
| Basic Connectors (SQL, JPA & Hibernate) | ||||||
| Queuing | ||||||
| HTTP Proxying | ||||||
| Excel Export | ||||||
| Advanced SQL & Hibernate connectors (templates; advanced search) | ||||||
| Automatic Transactions | ||||||
| Batch Uploader | ||||||
| Network Performance | ||||||
| OLAP / Datacube (Analytics) | 1 | |||||
| Real-time Messaging | 1 | |||||
| Pricing | Free | $745 / developer (bulk discount available) | $1950 / developer (bulk discount available) | Free / Varies (React: MIT; component libraries may add licensing costs) | ~$1,500+/yr per developer | Free to ~$2,000+/yr per developer |
Included Partial Available via third party See note Not available
1 Requires optional SmartClient / Smart GWT module.
Feature Descriptions and Samples
The following brief feature descriptions describe the features in the table above, and provide links to live examples and documentation.
Cohesive System:
When you adopt React, you have not yet chosen a technology you have chosen a programming style. The real work begins when you assemble separate libraries for grids, forms, charts, filtering, validation, state management, and server communication. Each library has its own data model, its own API conventions, and its own assumptions.
This “mix & match” approach appears to work in simple demos but creates compounding problems in real applications: inconsistent data binding forces redundant data services; cross-field validation becomes a nightmare when components handle values differently; modal/zIndex conflicts multiply as components are nested; accessibility compliance requires consistent keyboard handling and ARIA markup across all component vendors — nearly impossible to achieve; drag-and-drop breaks at library boundaries; and skinning five component sets means reconciling five styling systems, producing an inconsistent look no matter how much effort is spent.
The result is an explosion of glue code that grows with every feature and every upgrade becomes a high-risk event, since independent libraries change on independent schedules. “React experience” does not transfer between projects unless developers have used the exact same component combination.
A cohesive system like SmartClient eliminates every one of these failure modes. All components share a single data model, a single event system, a single layout engine, and a single skinning architecture. Data binding, validation, filtering, drag-and-drop, accessibility, i18n, and printing work uniformly across the entire UI because one team designed them as a unified system. (See also: Fallacies of React: Why So Many React Projects Fail.)
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 Filtering
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.)
Low Code Hybrid Dev:
Reify enables true hybrid development: business analysts and product managers build screens visually, producing clean Component XML that developers can extend in an IDE without losing the visual design. Unlike typical low-code tools that hit a ceiling, Reify keeps developers in full control while dramatically accelerating delivery for both simple and complex applications. Run your own private Reify server behind your firewall with Reify OnSite. (Examples: SmartClient; SmartGWT.)
AI Grid Features:
AI is built directly into SmartClient’s grid, not bolted on as a separate tool. End users can type natural-language requests like “show me overdue orders from the last quarter” and get an instant filtered, sorted, highlighted view. AI can generate entirely new computed columns by analyzing record content (e.g., sentiment, urgency, category), sort by subjective criteria, and summarize records on hover. No exports, no pipelines, no disconnected BI tools, just immediate insight within the live application. (Examples: AI Filter, AI Sort, AI-Generated Fields, AI Hiliting, AI Summarize on Hover.)
AI + Low Code:
Reify AI brings AI directly into the application platform. Developers and business users can generate complete, functional screens from natural-language descriptions, convert sketches into working UI, and explore enterprise data through conversational interaction, all within SmartClient’s cohesive architecture, so AI-generated results are consistent, secure, and fully integrated with existing application logic and DataSources. (Examples: Instant UI, Sketch to UI, Answer Engine, AI Assist.)
Server Data Binding:
Provides a simple Java API for handling requests for data from SmartClient visual components. Automatically parses complex nested search criteria, multi-level sorts, batch requests (multiple operations in one request), binary uploads, optimistic concurrency information (for “long transactions”) and other data into a Java request object with clean OO APIs. Can filter response data without the need for separate DTOs (Data Transfer Objects). This avoids hand-written code for request/response handling, which cannot reasonably be generated by e.g. JAX-B – see FAQ
Requests can be routed to Java classes via simple XML declarations, with a simple architecture for creating custom data connectors which are reusable across different entities. Can intelligently populate Java beans with validated request data, including automatic handling for nested objects, Enums and Generics, and optional XPath-based mapping between request/response data and Java structures.
(Examples: XML routing of requests to methods: SmartClient; SmartGWT. Custom data connectors: SmartClient; SmartGWT. Reusable custom data connectors: SmartClient; SmartGWT. Populating nested objects: SmartClient; SmartGWT. XPath-based structure mapping: 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
Excel Export allows any grid component to export to a spreadsheet or CSV file without writing any server code. Exported data respects column order, sort, search criteria, shown vs. hidden fields, data types (e.g. dates) and hiliting rules. Works with any DataSource type: SQL, JPA, Hibernate, or custom. (Examples: SmartClient; SmartGWT.)
PDF Export facilitates the export of any screen or set of widgets as a .pdf without the need to write any server code, with just a single API call (RPCManager.exportContent(widget)). Even works with charts, or with a mixture of widgets and charts. As with other export features, custom server code can take exported PDFs and attach them to emails, save them to databases, or forward them to other systems (Examples: SmartClient; SmartGWT.)
Chart Export, our HTML5 charts, and other widgets based on DrawPane can be exported to PNG & other formats. Charts also support PDF export, so you can export a grid full of data and corresponding chart to the same PDF.(PNG examples: SmartClient; SmartGWT. PDF 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.
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.)
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.)
Advanced Search & Aggregation:
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)
Declarative aggregation allows server-side grouping and summarization to be performed, including defining DataSource fields as aggregations of data in related DataSources. (Documentation: SmartGWT, SmartClient)
Advanced SQL and Hibernate Connectors
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.)
Network Performance Module:
A set of services designed for enhanced delivery of SmartClient applications in WAN, internet and extranet environments, including:
- 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.
- On-the-fly JavaScript stripping, combining and obfuscation driven from XML configuration.
- Network Performance Module Documentation
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.
Deeper Discussion (on question marked items)
Client-side Events and Adaptive Filtering:
Because of the inability to write client-side event handlers, server-centric technologies such as Vaadin, JSF and ZK have severe limitations:
- Offline or intermittently connected operation is impossible. If the network is unavailable the application becomes inert.
- Common application scenarios in which logic must run for every mouse movement (custom drag and drop) or every keystroke (rapid data entry) cannot be achieved with acceptable user experience & server load.
- Because of frequent server trips needed to run application logic, the application will always feel sluggish relative to client-centric solutions like SmartClient & Smart GWT, reducing user productivity. This is especially true when latency is high (mobile) or the server is heavily loaded. While this problem can be partly mitigated in hand-crafted demos, in actual application development this problem gets worse as more customizations are added, requiring more and more frequent server contact.
- Scalability issues because of greatly increased server load, due to:
- many additional server requests
- server-side memory footprint from having the entire UI component model in server memory, which can hamper virtualization efforts
- replicating the server-side state between servers in a high-availability clustered environment (NOTE: sticky sessions doesn’t solve this problem, as replication to at least one slave is still required to avoid data loss on server failure)
Because of these severe limitations, Isomorphic does not regard server-centric technologies as suitable choices for modern web applications. They are also extremely poor choices for enterprise-wide technology standardization: since there are so many scenarios in which an alternative technology must be used, the benefits of standardization (standard architecture, common tools, single set of skills to train and retain) are lost.
Server Data Binding:
As compared to our completely free offerings, server-oriented technologies make certain trivial server binding scenarios easier, such as hardcoded / tiny datasets. However they do not handle advanced data binding scenarios with the simplicity available with SmartClient Pro. (Master-Detail examples: SmartClient; SmartGWT.)
Sencha Price:
Single user pricing is not offered. The minimum purchase is for 5 users, costing $4,635 for GXT or $3,225 for Ext JS.
Timely access to Sencha patches requires a support subscription, otherwise, patch availability may be delayed by several months, as only major dot releases are available to licensees who have not have purchased support.
In contrast, patches to SmartClient and Smart GWT are immediately posted publicly, and licensed users are given special treatment on the SmartClient Forums.
For this reason Sencha’s combined license plus support price is more directly comparable to the license price alone for SmartClient / Smart GWT. Isomorphic then offers further support services, such as SLA-backed support plans with response time and resolution effort guarantees appropriate for mission-critical applications.
Vaadin pricing:
Features provided for free in our open source product are commercial add-ons in Vaadin, including Automated Testing support ($1200/developer), mobile support ($750/developer), and a Calendar component ($150/developer).
Furthermore, by the time you have also added Vaadin’s basic JPA support ($300/developer), you are now at price which exceeds our Power license with capabilities far less than our Pro license, and with the architectural drawbacks explained above.
