What if you could just talk to your datagrids and tell them what to do? That’s AI Assist for datagrids.

Imagine asking your application, in plain English, to “show all customers with overdue invoices”. SmartClient’s new AI Assist feature allows everyday users to interact with datagrids as if they were seasoned analysts, simply by using natural language.

AI Assist for Datagrids

The idea is simple but powerful: AI drives the existing UI on the user’s behalf. AI Assist is being added everywhere within SmartClient; however, with the release of SmartClient 14.x, the datagrid-specific AI Assist is production-ready. 

SmartClient grids are so powerful that even long-time users of SmartClient-based applications often don’t realize just how much they can do. Our grids aren’t just tables; they are full-featured analytics and reporting engines, capable of grouping, summarizing, filtering, pivoting, exporting, and more.

By combining this power with AI Assist, we’re giving ordinary users the capabilities of expert analysts, without the learning curve.

Configured by AI, Powered by SmartClient

Once the AI has done its job, configuring filters, sorts, summaries, or other grid settings, it steps aside. From that point forward, you’re interacting with a fully configured SmartClient grid using the standard UI.

Because AI Assist configures the grid using standard SmartClient APIs, it works transparently with our existing Saved Search features. Even though AI configures the grid, anyone you share it with doesn’t need AI to use it; they just get a fully functional, customized grid experience that behaves exactly as if it had been manually configured.

This spreads the power of AI even further into your organization: if one person has access to AI Assist, it’s as if everyone does.

AI Assist vs AI Data Enhance (AIDE)

Note that we do also offer AI features that involve record-by-record analysis of grid data, for things like sentiment analysis. This is our AIDE feature, and it lets end users make requests such as: “rank these customer complaints by urgency, based on the customer’s description of the issue”.

AIDE results can also be shared via Saved Search, but in the case of AIDE, the recipient must have AI access to use the search.

Enable AI Assist with a Single Property

Getting started with AI Assist couldn’t be easier. Once you’ve set your AI API key in server settings, it’s just a single property to turn it on in any grid:

canConfigureViaAI: true

Once this property is enabled on any ListGrid or TreeGrid, users will see a new option when they right-click on any grid header. This adds the “Configure via AI” menu item, giving them instant access to natural language configuration.

AI-Configurable Grid Features

AI Assist can be used to configure several key aspects of the grid by interpreting natural language input and translating it into standard SmartClient API calls. These include:

• Filtering: AI Assist generates AdvancedCriteria based on the user’s query and applies it as the active filter on the grid.
• Sorting: It can define one or more sort levels by updating the grid’s sort configuration in alignment with the user’s intent.
• Grouping: The AI can configure data grouping on any field, enabling grouped views directly through the UI.
• Hiliting: AI Assist can create or modify hiliting rules based on semantic conditions and apply them using standard hilite APIs.
• Visible Fields: AI Assist can update the set of visible fields by modifying the grid’s field configuration, hiding or showing fields as needed.

Use Case Examples

With just a plain-English request, AI Assist instantly shapes a meaningful view of the data. In this case, it uses natural language to manipulate the existing Orders grid, splitting it by customer to show each customer’s most recent orders, while also highlighting high-value orders in a different color to make them stand out.

The grid is neatly organized so that outdated or in-process entries don’t get in the way, and unnecessary fields stay hidden. The result is a clear, actionable view that surfaces the right information at the right time without anyone needing to dig through settings or write complex queries.

Once the prompt is applied, you can see the full transformation of the grid, all powered by a single user request and executed via our native APIs. Explore the Configure Grid sample.

If you’re a current customer or an active member of the SmartClient community, you should already have access to the sample. Just make sure you’re logged in. Can’t access the demo? No problem, simply Contact Us and we’ll get you set up with the appropriate access.

And that’s just one example. AI Assist can adapt to all kinds of scenarios. For instance, here’s how it handles issue tracking, taking your prompt, applying the right filters and groupings, and setting everything up so you can get straight to work.

AI Assist makes it effortless to track issues by turning a simple request into a ready-to-use grid. In this case, it highlights what matters most: each team member’s open tasks, with the oldest issues surfaced first, so nothing slips through the cracks. Closed items are automatically filtered out, keeping the view clean and focused. The result is a clear, prioritized snapshot of team workload created instantly, without the hassle of manual setup.

Check out the Configure Grid sample for yourself here.

Hilite via AI (AI Assist)

With AI Assist, highlighting key metrics becomes as simple as describing what you want in plain language. Instead of manually configuring complex rules, a user can just say which fields and thresholds matter, and the grid instantly applies the right formatting. In this example, large populations and low GDP values stand out with clear visual cues, making critical insights easy to spot at a glance.

This kind of AI-driven conditional formatting is ideal for monitoring critical reporting, exception spotting, or highlighting thresholds for high/low risk indicators, all without requiring manual rule setup or technical knowledge. Check out the sample.

Filter by AI: A Focused Alternative

We also offer a Filter by AI (AI Assist) feature that highlights a simpler interaction: using AI only to adjust the grid filter. Some may prefer showcasing AI in this narrower way, focusing specifically on enhancing the filtering experience rather than exposing the entire grid configuration through natural language.

To check out Filter by AI, see the sample.

Ready to Add AI to Your Grids?

All of the features shown, including Configure via AI, Hilite via AI, and Filter by AI, are available now in SmartClient 14.x as separately licensed technologies.

There has never been a better time to add AI to your applications. SmartClient’s AI Assist makes it easy to do so, providing a powerful and low-effort way to show that your organization understands the value of AI and is leading the way in innovation.

Interested in adding AI Assist to your application? Contact us for licensing details and access. Some features may also be supported on SmartClient 13.x builds depending on your use case, so let us know if that’s something you need.

With SmartClient 14.x, we’ve made it dramatically easier to adopt multi-tenancy, without rewriting your application logic.

SmartClient now offers transparent multi-tenancy, a turnkey solution that lets developers scope data access by tenant using just configuration changes, without redesigning an application for multi-tenancy.

Whether you’re building a new SaaS product or retrofitting an existing system, SmartClient 14.0 ensures your application is multi-tenant ready with minimal effort.

This article will walk through how SmartClient’s transparent multi-tenancy works and what it means for your architecture.

What Is Transparent Multi-Tenancy?

Transparent multi-tenancy means your application continues to work exactly as written, but now supports multiple customers with securely segregated data. Grids, editors, validations, RPCs, and business logic all work as before, while SmartClient handles all the tenant-scoping behind the scenes.

Client and server logic don’t need to change. Once the authenticated tenant ID is provided, all operations, including data loads, saves, validation, and business rules, are automatically scoped.

Tenant‑Specific DataSources

As with all things in SmartClient, transparent multi‑tenancy is based on DataSources.

Everything in your existing application that references DataSources – grids, forms, data binding, validation – continues to function seamlessly in a multi-tenant environment. The framework handles tenant scoping automatically under the hood, so there’s no need to refactor your user interface or server-side code.

Whether you are fetching, adding, updating, or deleting records, SmartClient ensures that all data operations are transparently scoped to the correct tenant’s context. Developers don’t need to manually inject tenant filters or adjust their CRUD logic; SmartClient handles this natively and automagically.

How It Works

Tenant-specific, but same ID in the browser

Server-side, when you call DataSource.get("orders")SmartClient automatically generates a tenant-specific version based on a naming convention like mt_biginc_orders, where the DataSource’s database configuration is dynamically determined based on server-side configuration (server.properties). However, on the client, even if the real ID might be mt_biginc_orders, it’s aliased back to just “orders“, meaning your UI code remains identical – zero changes required.

Server-side automatic scoping

You don’t even need to change server-side business logic! Once the tenant ID is set via RPCManager.setTenantId(...) or isc_tenantId on the servlet request, any server-side data requests, whether via RPCManager.getDataSource(), new DSRequest(), etc., automatically use the tenant-scoped DataSource definition.

Global (non-tenant-specific) data: just configure

Sometimes you need global DataSources that aren’t tenant-specific. Examples would be geographical information or shared catalogs.

It’s easy to exclude such DataSources from the multi-tenancy system – just place them in a separate directory, and SmartClient’s multi-tenancy system treats them uniformly across tenants. The whole system remains transparent even when you need to do a ‘join’ (like a SQL JOIN – whether actually SQL or not) between general and tenant-specific DataSources.

Flexible Database Partitioning

It’s ridiculously easy – a matter of just a couple of declarations in a .properties file – to set up either a separate ‘schema’ per-tenant within the same database server, or, if you prefer, an entirely separate database server per-tenant, with a naming convention so SmartClient can find the database server.

This uses the same database configuration approach you are already using (server.properties), but now, you have a $tenantId variable.

For example, your configuration can specify unique connection settings, such as database name, JDBC URL, or even database host, based on the tenant ID.

This approach enables clean separation of tenant data at the schema level, or even across entirely different databases or database servers. It provides maximum flexibility for scaling, performance tuning, and security. 

Best of all, switching between partitioning strategies, whether schema-based, database-based, or host-based, can be accomplished entirely through configuration changes.

Simple App Changes Required

For many apps, it’s amazing how easily transparent multi-tenancy can be enabled. An existing app requires a very short list of configuration tweaks.

When loading DataSources (via a script tag calling the DataSourceLoader servlet, or DataSource.load() call), just pass the authenticated tenant ID, and the framework loads a tenant-specific DataSource.

On the server side, provide the tenant ID programmatically with RPCManager.setTenantId() or via a servlet request attribute. With that in place, all data operations are automatically scoped per tenant. 

You can also provide tenant-specific variations on your DataSources. Does one tenant want to store a particular additional field? Place a custom DataSource under the tenants/ directory, and you’re all set.

Multi- Multi-Tenancy Models

SmartClient 14.0 supports all common models of multi-tenancy:

• Silo Model: Each tenant has its own isolated DB instance or schema.
• Bridge Model: Tenants share a DB process, but have isolated datasets.

server.properties determines the layout of your tenant-specific data: schema, database, or hostname, it’s all based on the tenant ID. These small changes are all it takes to make your app fully multi-tenant, secure, and SaaS-ready.

Built-in Demo App

SmartClient 14.0 includes a ready-to-run multi-tenant Order Management demo in the SDK. Flip between tenants using a simple URL parameter (for demo purposes). This lets you test multi-tenant behavior instantly and observe how transparent scoping works.

Ready to Make Your App SaaS-Ready?

With SmartClient 14.0, adopting multi-tenancy is easier than ever: no rewrites, no complex logic changes, just simple configuration updates. Whether you’re building a new SaaS application or modernizing an existing system, SmartClient’s transparent multi-tenancy gives you a powerful, scalable foundation with minimal effort. 

You can see it in action right away with the built-in multi-tenant Order Management demo included in the SDK. To get started, download the latest SmartClient SDK, explore the documentation, or contact us for a personalized walkthrough. It’s the fastest path to delivering secure, tenant-aware applications, ready for SaaS, right out of the box.

At Isomorphic, we believe every UI component should come with built-in AI. That vision is now a reality.

We’re excited to introduce AIDE (AI Data Enhancement), our newest set of generative AI features designed to live directly inside your components. Think of AIDE as an on-demand data analyst living inside your grids, ready to summarize, categorize, sort, or filter your data by deeply examining each record.

It’s not just about asking your app what to do. That’s the job of AI Assist,  our natural language interface, which lets users issue commands like “Show orders over $30k in the last nine months, starting with the largest order.” And it’s distinct from Answer Engine, which responds to business questions with full dashboards across your enterprise.

AIDE goes further: it reads the actual data records and augments them intelligently, one row at a time. To explore these features hands-on, visit the AI Sample Gallery.

AIDE at a Glance

Here are the first three AIDE features landing in SmartClient:

• AI-Generated Fields: Enrich each row of your data grid with AI-generated summaries or other context. Or, do it as a hover.
  
• AI Filter: filter the grid by examining each record and applying dynamic, AI-powered criteria, such as relevance to your current task.
  
• AI Sort: sort by dynamic, AI-powered rankings, such as how time-sensitive an issue is, or how much it could impact your company’s bottom line.

AI Filter: Discover What Traditional Filters Miss

Traditional filters rely on structured values, specific fields, exact matches, and rigid criteria. But real-world data is often messy, unstructured, and nuanced. AIDE’s AI Filter breaks through these limitations by filtering based on meaning, not just data values.

Sometimes users don’t need every record; they want only the ones that feel relevant, highlight critical issues, suggest promising outcomes, or flag potential risks. With AI Filter, users simply write a short prompt describing what they care about. AIDE interprets the intent and filters the dataset accordingly, returning only the records that align with the prompt’s meaning.

For example, in the ScienceStudies sample dataset, a researcher is trying to figure out which recently published studies are relevant to safety for a particular medical device. Normal filtering absolutely cannot do that, but AI-based filtering can.

Similarly, in the “countries” dataset, the AI uses its encyclopedic knowledge to filter to Spanish-speaking countries. Now you know how to focus your ad buys!

AI Filter isn’t rule-based. It’s insight-based. It understands the nuance in unstructured data, making it ideal for narrowing incident queues, screening leads, or identifying meaningful research findings. With just a prompt, users unlock filters powered by comprehension, not configuration.

Check out AI Filter Sample.

AI Sort: Prioritize What Matters

Traditional sorting, by name, date, or numeric fields, can’t reveal what’s truly important. AI Sort, powered by AIDE, goes beyond superficial ordering of rows and columns. It sorts based on meaning, relevance, and impact, so users see what matters first.

With AI Sort, users define what “important” means in plain language. Want to surface the most novel research, highest urgency issues, or greatest revenue opportunities? Just ask. AIDE interprets the intent and reorders the grid accordingly. The most relevant rows rise to the top, while the noise fades away.

In the UserIssues dataset:

In the WorldDS dataset:

• The AI uses its knowledge of global geopolitical context to rank countries by press freedom
• AI dynamically decides upon a ranking, so rankings are consistent, even if the dataset changes

Whether it’s prioritizing support tickets, research studies, or global metrics, AI Sort transforms your grid into a smart list, ranking not by what’s there, but by what it means.

Check out AI Sort Sample

AI-Generated Fields: Augment Records Instantly

With AI-Generated Fields, every row becomes more than raw data. AIDE lets users add new fields computed on demand by AI, based on prompts tailored to the dataset. It enriches records with fresh, relevant insight.

These AI-generated fields appear instantly and feel native to the data. They bring external knowledge, synthesized insights, and smart classification, all embedded right into the grid.

We’ve seen research relevance, business impact, but for some travel-planning fun, in a dataset representing countries, you could ask for a short demographic overview, list common religions, or name the most famous landmark, all per country.

Take a look at the AI Generated Fields sample.

Production-Ready AI, Built for Real Workloads

AIDE’s AI features aren’t just demos or proof-of-concepts; they’re built for real-world deployment at scale. Whether you’re working with hundreds or hundreds of thousands of records, AIDE is designed to perform reliably in production environments.

To overcome generative AI’s context window limitations, the SmartClient grid intelligently processes data in configurable batches. You control how many records a user can enhance with AI, whether filtering, sorting, or augmenting content. 

For example, if AI is limited to processing 300 records at a time and a user tries to filter across 5,000 rows, the grid will automatically disable the AI feature and explain why, ensuring clarity without breaking the experience.

It’s a seamless safeguard: no broken UX, no guesswork, no developer intervention. That’s the kind of polished, production-grade usability SmartClient is known for, AI that’s powerful, practical and deployable at scale.

Saveable, Shareable Intelligence

AI filters and sorts aren’t just ephemeral interactions. They can be saved as part of a Saved Search, shared across your organization, and reused just like any traditional filter or sort. To see Saved Search in action, check it out here.

A user might save a “Most Impactful Safety Studies” view or a “Highest Urgency Issues” list, all backed by AI, and all fully integrated.

API Access, Naturally

Need AI-enhanced results outside of a grid? No problem. AIDE is fully accessible through API calls like: isc.AI.filter(records, prompt). Whether you’re using grids or not, SmartClient’s AI and advanced features can be part of your workflow.

isc.AI.filter(records, prompt);

More Component-Level AI Is Coming

AIDE is just the beginning. In our labs, we’re already testing:

• AI-Assisted Form Autofill
• AI Data Insights are shown inline in every grid
• AI-Augmented Layouts and Reports
• Answer Engine

If you want to be the first to sport such features in your apps, you can get involved via Feature Sponsorship. We take requests!

Get Started Today

AIDE features are available now in SmartClient 14.x as a separately licensed technology. Some features are also supported on 13.x. Contact Us to request access, preview the samples, or get started with production deployment. 

With the release of SmartClient 14.0, we’re introducing a range of server-side data management capabilities that simplify complex data transformations and boost performance for large datasets. This update includes calculated fields, and server-formatted fields. These features make it easier to manage, format, and retrieve data dynamically and efficiently.

This blog will cover these advanced data-handling features and explain how they enhance SmartClient applications for developers and end users.

Calculated Fields

Calculated fields in SmartClient 14.0 allow you to define fields based on formulas, enabling the creation of dynamic, computed values directly in the DataSource. Simply define a formula using existing fields, and SmartClient handles the rendering, sorting, and filtering. If you’re building dashboards or reports, calculated fields eliminate the need for extra backend logic.

Here is an example of a calculated field that dynamically computes a totalCost field by multiplying unit price by quantity ordered:

<field name="totalCost"
       type="float"
       decimalPad="2"
       decimalPrecision="2"
       format=",0.00">
    <formula>quantityOrdered * priceEach</formula>
</field>

The image below showcases how this works in a grid, with the Total Cost field calculated on the server using the defined formula.

Key Features

• Formula-Based Definitions: You can define fields that compute their values based on other field data. For example, an order item can include an overallPrice field calculated as price * quantity.
  
• Full Integration with Reify: Calculated fields work seamlessly with Isomorphic’s low-code platform, Reify. Even non-developers can define formulas visually to create views and summaries (like order totals) without writing code.
  
• Filterable and Sortable: They behave just like regular fields. You can filter, sort, and aggregate them without additional configuration.

SmartClient 14.0 makes it easy to define computed virtual fields declaratively. This enables complex transformations entirely on the client or server, simplifying insight generation within your application.

Previously, formulas and templates were computed only in the browser, meaning you couldn’t sort or filter large datasets based on these fields. With server-side support, SmartClient now handles these calculations directly in the backend, enabling fast, scalable operations even across 10 million+ records.

To see it in action, check out the sample here. Additional documentation can be found here.

Server-Formatted Fields

SmartClient 14.0 also introduces server-formatted fields. These fields are formatted on the server rather than the client, which is crucial when dealing with large datasets where sorting and filtering must use the formatted value. In use cases involving millions of records or composite values (like $lastName, $firstName), server-formatted fields ensure accurate and efficient sorting and filtering.

When the template attribute is declared in the DataSource, SmartClient modifies the generated SQL (or equivalent backend logic) to compute the formatted result server-side.

Here’s an example:

<field name="compositeName"
       title="Full Name"
       length="100">
    <template>#{lastName}, #{firstName}</template>
</field>

This might produce an output like Abbott, John. Because the value is server-generated, filtering and sorting operate correctly, even when only part of the dataset is loaded in the browser.

Key Features

• Server-Based Formatting: You can configure fields to be formatted on the server, improving handling for high-volume datasets.
  
• Improved Performance for Large Data Volumes: Server-formatted fields reduce client-side load and improve query efficiency, especially when working with datasets of five million records or more.
  
• Declarative Flexibility: You can decide whether a field should be server- or client-formatted based on application complexity. Server formatting is ideal for high-scale enterprise apps, while simpler apps can continue using client-side formatting. It delivers real-time responsiveness for data-heavy apps without compromising speed or usability.

To see it in action, check out the sample here. Additional documentation can be found here.

Conclusion

SmartClient 14.0 introduces key enhancements in server-side data handling. These include calculated fields and server-formatted fields. Together, they provide powerful tools to efficiently manage, format, and display data at scale.

These features simplify complex data logic, improve responsiveness for large datasets, and empower developers to build scalable, data-rich applications with an enhanced user experience using less effort.

Upgrade discounts are available for licenses purchased within the last 3 months. View our License FAQs for more details, or contact us to discuss your upgrade options.

All known affected licensees were already notified 3 weeks ago; however, if you are just now learning of this:

TL;DR

• Severity: CVSS 9.8 (Critical) – CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
• Affected: SmartClient Server (also used by SmartGWT) when SQLDataSource is in use
  • 13.0+: logged-in attacker could blind-execute arbitrary SQL (potential data corruption, downtime, possible exfiltration with schema knowledge)
  • Older releases: in addition to the above, attacker could potentially execute arbitrary programs on the host
• Fixed: Patched builds have been available for weeks at smartclient.com/builds.  As usual, grab the latest even though the exploit was corrected a while back.
• What to do: Update to the latest patched build immediately, especially if your app is exposed to untrusted users.
• Disclosure cadence: Licensees notified first; broader registered users notified two weeks later; public technical details posted now.

Who should act

If you deploy SmartClient Server / SmartGWT with SQLDataSource, assume you are impacted and patch now. This applies regardless of whether you use Custom Querying-this issue is deeper than that surface area.

Patched builds:

• https://www.smartclient.com/builds

Note on legacy releases:
Versions 11.1 and earlier reached end-of-life over 3 years ago. Custom backports may be possible via Hourly Support:

• EOL notice: https://blog.smartclient.com/support-schedule-for-11-0-and-11-1/
• Support: https://www.smartclient.com/services/#support

Timeline & disclosure

• Day 0: Vulnerability confirmed; trivial, targeted fix implemented and tested within hours.
• Day 1: Initial advisory sent to all known licensees, including severity (CVSS 9.8) and upgrade instructions.
• +14 days: Second advisory sent to all registered smartclient.com accounts to catch any users not in the licensee records.
• Now: Public technical explanation (below) posted, with exploitation-enabling details deliberately omitted.

This aligns with standard responsible disclosure: notify affected users privately first, allow a patching window, then share technical detail publicly.

Impact summary (non-exploit detail)

• 13.0+ with SQLDataSource: a remote, authenticated attacker could issue blind SQL operations. This can cause downtime (e.g., dropped/corrupted data), data integrity issues, and potential data exfiltration only if the attacker already knows your schema well enough to extract signals.
• Older versions with SQLDataSource: all of the above, plus a path that could lead to arbitrary program execution on the host.

We have no evidence of real-world compromises resulting in anything beyond minor service disruption. No confirmed data loss, no confirmed remote control of servers.

Technical overview (high level)

We’re sharing enough depth to explain root cause and lessons learned, without including PoC or step-by-step exploit content.

There is a part of the standard SmartClient server request from the client called operationConfig. It contains things like startRow/endRow and sortBy.

• Historical behavior (2005): server code merged operationConfig into the server-side DSRequest object. At the time, this was not a security issue and provided a convenient way for client code to add custom attributes that the server could read to adjust behavior.
• Refactor (circa 2019): the server flow was refactored for better caching and resource cleanup. Certain attributes (like customSQL) started being cached on DSRequest.
• Interaction effect: the combination meant a client could inject properties into DSRequest that overrode cached attributes, unintentionally controlling sensitive server behavior.
• A third factor involved a timing change in when DSRequests were set up on the server, such that operationConfig could now overwrite developer-specified settings, instead of being clobbered by them.  

So, three independent shifts lined up to create the exploit path.

The fix: we constrained operationConfig to a tight allowlist of safe properties (this already existed on the client side); we ensured no sensitive server-only attributes can be influenced by client-provided state.

Why this is rare for us

Isomorphic was founded by people with extensive backgrounds in network security, which is why this is only the second vulnerability ever found in SmartClient Server code (excluding third-party dependencies) in nearly 25 years. 

The previous one was a minor information disclosure, so this is basically the first substantive security issue.  That’s quite the track record, if we say so ourselves!

In addition, three distinct evolutions in behavior had to combine to produce this issue.  This was not a matter of forgetting to think about security, but rather of thinking carefully about security at 3 different times, getting it right each time, and then missing an extremely subtle interaction.

Here’s hoping we have another very, very long run with no exploits.

What to do next

1. Upgrade to the latest patched build: https://www.smartclient.com/builds
2. Validate that all nodes/containers/images in your deployment are updated.
3. Review logs around upgrade time for anomalous SQL activity or unexpected server-side execution (if you’re on older versions)

If you’re on an EOL release and cannot upgrade immediately, contact us; we can discuss custom backports via Hourly Support.

Credits

A huge thank you to Marcos Garcia Chillon (EUMETSAT), who reported the flaw and demonstrated a working exploit. Marcos, the entire SmartClient / SmartGWT community owes you one.

We are sending Marcos a very nice gift as a thank you.

Closing

We moved fast, communicated privately first, and are now sharing the technical picture responsibly. If you have questions about your specific deployment or need help validating your patch, reach out to Support.

– Isomorphic Software Support

SmartClient 14.0 introduces powerful new capabilities for managing data, making advanced querying more accessible and flexible than ever. These enhancements dramatically expand the potential of SmartClient grids and forms, turning them into dynamic, full-featured reporting tools.

Whether you’re building complex reports or working with interconnected data, these new features enable faster and more efficient data handling, both for developers and end-users.

In this post, we’ll explore the following features:

• Criteria on Related Entities
• Aggregation and Subqueries in Criteria
• KeepParentsOnFilter for Load-on-Demand Trees

Criteria on Related Entities

In real-world applications, querying data from a single entity is often insufficient. You need to filter records based on related entities. For example, when viewing orders, you may want to filter based on the properties of the related customer or sales representative.

SmartClient has long supported this use case, but with 14.0, it’s now completely declarative. You can define criteria directly on related entities using simple AdvancedCriteria syntax:

{
        fieldName: "Employee.email",
        operator: "equals",
        value: "[email protected]"
}

This example, applied to the Order DataSource, would return only those orders created by a specific sales rep. SmartClient automatically resolves the relationship between Order and Employee, applies the necessary SQL join (or the equivalent operation for non-SQL backends), and filters the results.

There’s also built-in UI support: the FilterBuilder component now includes a “Related field…” option when selecting filter fields.

This enhancement means your end users immediately gain access to this power via the AdvancedFilter window in any ListGrid.

Better still, related-field filtering works with Saved Searches. Power users can define advanced filters on related fields, save them, and share them with others.

If you’re using SmartClient AI Assist, it already understands how to use these features, no additional configuration needed.

See the Filter Related Fields sample to learn more.

Aggregation and Subqueries in Criteria

Filtering on related entities is powerful, but we’ve gone even further. SmartClient 14.0 introduces aggregation and subqueries directly into the criteria system.

Say you want to find all “In Process” orders where the customer has spent at least $20,000. This can now be done declaratively:

    {
        "operator":"and",
        "criteria":[
            {
                "fieldName":"status",
                "operator":"equals",
                "value":"In Process"
            },
            {
                "operator":"greaterOrEqual",
                "value":"20000",
                "fieldQuery":{
                    "groupBy":[
                        "customerNumber"
                    ],
                    "summaryFunctions":{
                        "amount":"sum"
                    },
                    "dataSource":"Payment"
                }
            }
        ]   
    }

SmartClient allows both the field and value in a Criterion to be dynamic, based on queries or summaries over related DataSources. These can include sum, max, or any aggregation logic you need.

There’s also full UI support. The FilterBuilder now includes tools for defining subqueries, giving semi-technical users (like Product Managers) the ability to build complex filters without writing a single line of code.

This functionality:

• Works seamlessly with Saved Searches
• Is supported by SmartClient AI Assist
• Is enabled by default in all ListGrid AdvancedFilter windows

These features collectively turn any grid into a full-fledged reporting engine, with complex querying available through simple declarative expressions. And in Reify, SmartClient’s low-code platform, non-developers can define these sophisticated queries just by pointing and clicking.

See the Aggregated Filter sample for more details.

KeepParentsOnFilter for Load-on-Demand Trees

A common request with tree views:
“When I filter, keep the parent nodes of any matching items visible, even if the parent itself doesn’t match.”

While easy to support in small, preloaded trees, this becomes a massive challenge in load-on-demand trees. Until now, no other UI framework has solved this cleanly.

SmartClient 14.0 introduces KeepParentsOnFilter, which preserves parent nodes in filtered views, even with dynamic loading. The feature intelligently loads “skeleton branches” as needed, keeping performance high without preloading the entire tree.

It just works with any server-based DataSource. And if you’re using our SQLDataSource, efficiency reaches another level.

Enable the feature in your TreeGrid config and you’re done. SmartClient handles the filtering logic, data loading, and UI rendering.

Check the showcase for more details on how this works.

Conclusion

SmartClient 14.0 turns grids and forms into true data engines. With the ability to filter on related entities, use subqueries, and apply aggregations, your users gain unprecedented power over exploring and analyzing data.

These features allow your applications to:

• Execute multi-entity queries without custom server logic
• Build aggregated views and reports directly in the UI
• Present dynamic calculated fields in real time

Combined with AI Assist and Reify, these capabilities are usable by everyone, from power users to non-technical staff, without writing or maintaining custom code.

SmartClient 14.0 continues to push enterprise-grade productivity to new heights.

Free upgrades are available for licenses purchased within the last 3 months. If you’re outside that window, discounted upgrade pricing may apply.

See the Upgrade Discounts section in our Licensing FAQs for details, or contact our sales team to check your eligibility or request a custom quote.

SmartClient 14.0 fully automates the display, editing, and update of data relationships – including one-to-many, many-to-one, and many-to-many. You simply declare the relationship in your DataSource, and SmartClient does the rest. No coding required.

This capability is powered by three major features: Relation Fields, MultiPickerItem, and the Shuttle Interface. Together, they provide a declarative, scalable, and user-friendly approach to managing relational data.

Relation Fields

In both databases and object-oriented systems, a relation connects an object to one or more other objects. A classic example is an order with multiple line items (1-to-many). More complex are many-to-many relationships, such as students enrolled in multiple courses, with each course having multiple students.

A common setup involves three tables: one for each main entity (for example, Employees and Teams) and a connector table (such as TeamMembers) linking them.

With SmartClient, you can add a multi-valued field (for example, teams in the Employees table) that uses a foreignKey through the link table to the related table. A fetch automatically looks up the related records in the pivot table and populates the array of IDs. The includeFrom setting can bring in display values like names.

When you update that array, SmartClient automatically updates the link table, adding, removing, or replacing relationships, with no extra code required. This means you can manage many-to-many associations entirely through declarative configuration.

<field 
    name="EmployeeId" 
    title="Employee" 
    displayField="EmployeeName" 
    foreignDisplayField="Name"
    foreignKey="teamMembers_relation.employees_relation.EmployeeId" 
    multiple="true" 
/>
<field 
    name="EmployeeName" 
    hidden="true" 
    includeFrom="employees_relation.Name" 
    multiple="true" 
/>

This setup connects teams to employees (a Many-to-Many relation) and handles everything from value resolution to text display with no additional logic.

Key Features

• Declarative configuration: Just declare a field as a relation to another DataSource. Whether your backend is SQL, JPA, REST, or anything else, SmartClient automatically handles all data retrieval and update operations.
  
• Instant, Codeless UI: Bind a grid or form to a DataSource with Relation Fields, and SmartClient instantly renders UI controls for viewing and editing those relationships, no additional code needed.

See the Relation Field showcase for live examples.

Editing Related Records: Shuttle Interface and MultiPickerItem

To complement Relation Fields, SmartClient 14.0 introduces two powerful UI components for managing many-to-many relationships: the Shuttle Interface and MultiPickerItem. Each is designed for different usage contexts, one for inline form editing, the other for full dual-grid interaction.

MultiPickerItem

MultiPickerItem is a compact UI control for selecting multiple related records. It’s automatically used in forms when a field has a multi-valued foreignKey and requires no manual configuration. It provides an intuitive UX for choosing related records. That includes displaying selected values as a comma-separated list and opening a pop-up list for editing selections using checkboxes.

The foreignKey relationships allow you to add additional fields to tables that refer back to an existing table. These link tables can automatically populate an array of values from the existing table.

In forms, MultiPickerItem is used automatically when the field has a multi-valued foreignKey. In editable grids, you can enable it by specifying:

editorType: "MultiPickerItem"

The example below shows MultiPickerItem in an editable grid. Selected values appear inline, and the pop-up allows users to select from a related DataSource using checkboxes.

Explore the MultiPicker Fields sample.

A related component, SetFilterItem, is used in search forms and filter UIs. It provides a simple, checkbox-based UI for selecting multiple filter values, and supports inclusion and exclusion operators such as “is one of” and “is not one of”. This makes it easy for users to define in-set or not-in-set filters without needing custom logic.

SetFilterItem is automatically shown when users choose these operators in a filtering context. It’s designed to help users define in-set or not-in-set criteria without needing to understand the data structure underneath.

You can see this in action in the image below, where the Category field uses SetFilterItem to build filter criteria visually.

Explore the Set Filtering sample.

Shuttle Interface

The Shuttle Interface is a full dual-grid control ideal for visual editing of many-to-many relationships. It displays all available records on the left and selected records on the right. Users can drag, double-click, or use arrow controls to move records between panels.

Shuttle is available as a standalone component that can be embedded directly in forms, modals, or any layout, and a ShuttleItem, a subclass of MultiPickerItem that uses the Shuttle appearance.

Key Features

• Dual-panel interface: Users see all available items on the left and selected items on the right. They can move items between panels with a click, eliminating the need for dialogs or separate editing views.

• Inline and pop-up support: You can embed the Shuttle directly inline, in modals, or in forms, wherever a full visual editor is needed. This lets you adapt the component to your specific UX requirements.
  
• Automatic binding with relation fields: When used with Relation Fields, the Shuttle Interface binds automatically. You define the relationship, and SmartClient handles the rest, including data loading, UI generation, and value updates.

The Shuttle Interface is perfect for assigning users to teams, allocating resources to projects, or managing memberships in complex systems. It gives users a simple, fast way to handle multi-item associations without needing to understand database joins or linking tables.

Check out the Shuttle Interface showcase to see it in action.

Conclusion

SmartClient 14.0 removes the pain of managing relational data. With Relation Fields, you can define complex relationships declaratively and instantly present them using powerful UI components like MultiPickerItem and the Shuttle Interface, all without writing a single line of code.

Whether you’re editing linked records, managing membership lists, or working with nested relationships, SmartClient 14.0 delivers the tools to handle it all with minimal setup and maximum efficiency.

If your license was purchased recently, you may either be eligible for a free upgrade or for discounted pricing.

Check the Licensing FAQs for details. To confirm your eligibility or request a quote, contact our sales team.

In today’s data-driven business environment, the ability to quickly extract meaningful insights from enterprise data is no longer a luxury but a necessity. Yet for most organizations, the process remains frustratingly complex: data analysis typically requires specialized skills, custom report development, or reliance on pre-built dashboards that may not answer your specific questions.

That’s why we’re thrilled to announce our latest innovation: SmartClient Answer Engine (AE), a groundbreaking approach to enterprise data exploration that will transform how you interact with your business data.

Ask Questions, Get Answers. It’s That Simple

Imagine asking your application plain-English questions like “What’s causing the recent sales drop in California?” or “Which sales rep has improved the most over the last year?” and immediately receiving a complete, shareable dashboard with the visualizations and data grids that answer your question.

That’s exactly what SmartClient Answer Engine delivers: no specialized queries, no waiting for IT, no complex setup.

What Makes SmartClient Answer Engine Different

While generative AI is making waves across industries, SmartClient AE stands apart in several critical ways:

1. Zero Training Required

Unlike many AI solutions, AE works with your existing SmartClient DataSources out of the box: no model training, no data preparation, no waiting. It simply connects to your existing application data model and starts delivering insights immediately.

2. Declarative and Inherently Safe

AE generates declarative dashboard definitions and queries, not SQL or JavaScript, eliminating the risk of unexpected behavior. This declarative approach makes outputs easy to audit and safe to share across your organization.

3. Breakthrough Anti-Hallucination System

In a world where AI hallucinations pose significant risks, we’ve developed something truly unique. Our Anti-Hallucination System automatically validates all AI-generated output against known SmartClient properties. 

When the AI suggests something invalid, the system provides immediate feedback, allowing the AI to self-correct without any user intervention.

This capability is exclusive to SmartClient and simply impossible with other technologies. Because SmartClient is inherently high-level and declarative, entire dashboards and queries can be expressed in as little as 50 lines of JSON or XML. 

Compare this to traditional frameworks like React, where generating equivalent functionality would require thousands of lines of code with hundreds of potential error points that couldn’t feasibly be validated.

4. Enterprise-Ready

AE is built with enterprise requirements in mind:

• Security-First Design: AE respects your existing security model, with access limited to what the current user is authorized to see and do
• Powerful queries: Answer Engine leverages the full power of DataSource features, using advanced search criteria, grouping and summarization, and even aggregated subqueries.
• Browser-Based Processing: Minimizes server load by performing most work in the browser 
• Result Caching: Automatically caches previous results for optimal performance
• Built-In Collaboration: Share insights across your organization with built-in sharing capabilities

5. Seamless Integration

Adding AE to any SmartClient application requires just two lines of declarative code. The polished user interface manages answer history, concurrent executions, and result sharing with no additional development effort.

Everything, Everywhere, All at Once

SmartClient DataSources can represent any kind of data: REST services, Parquet shares, document servers, whatever.
DataSources can also represent services that answer questions, such as Morningstar investment risks, Watson document insights, or LexisNexis fraud risks.
Answer Engine can leverage all of the above.  To answer a particular question, AE might consult local databases, consult internal documents, pull data shared to you by a partner, check local DBs again and finally summarize the whole process in a dashboard.

Not Just SmartClient: Easy to Embed in any App

It takes just a couple of lines of code to embed Answer Engine in any web application – it doesn’t have to be based on SmartClient.

It’s also very straightforward to create the DataSources that allow Answer Engine to securely access data and to automatically recover from hallucinations.  In some cases, we have tools to automate the process (SQL, JPA, etc).  For others, we have pre-built connectors.  For yet others, we’ve made it as simple and declarative as possible to connect to your custom data or service.

While there are a lot of very good reasons to port existing applications to SmartClient, you don’t need to do so to get Answer Engine – you can have it right now!

The SmartClient Advantage

SmartClient Answer Engine represents a fundamental breakthrough in enterprise data exploration, one that’s only possible because of SmartClient’s uniquely declarative, high-level architecture.

While other platforms might claim similar capabilities, they simply can’t deliver the same level of reliability, security, and ease of use. When generative AI attempts to create complex visualizations and queries in traditional frameworks, the resulting code is too voluminous and error-prone to be practically validated or corrected.

SmartClient is the only technology where AI can feasibly generate complete dashboard responses to data questions and be reliably corrected when it makes mistakes.

Coming Soon

SmartClient Answer Engine is currently in preview at select customers, and you can join the preview program if you contact us.  Customers in the Preview Program not only receive early access to Answer Engine, but can also help to shape the Answer Engine via Feature Sponsorship, receiving steeply discounted or even gratis licenses in return.

Want to learn more about how SmartClient Answer Engine could transform data exploration in your organization? Contact our team today. For more information on Answer Engine, check out this video here.

We’re always working to give you the best tools and experiences, so we regularly review and update our platform to keep up with modern standards. With that in mind, we’re announcing the schedule for support changes to older versions of SmartClient.

Why This Change is Necessary

Technology moves at an incredible pace, and maintaining older versions of the platform becomes increasingly challenging and less effective over time. Here are the primary reasons for this shift:

1. Browser Compatibility: SmartClient is designed to work seamlessly with the browser versions that are available at the time of a version’s release. However, as web browsers evolve, older versions of the platform struggle to maintain compatibility, leading to performance issues or limited functionality for users.
2. Security Enhancements: Security is one of our highest priorities. Older versions lack critical updates that protect against modern threats. By focusing our efforts on supporting newer versions, we ensure our platform remains secure and resilient.
3. Performance and Features: Advancements in technology have enabled newer versions to provide better performance and a richer feature set. Continuing to support outdated versions diverts resources from building tools and features that help our users succeed.

We know that change can sometimes feel overwhelming, but we’re committed to making this transition as smooth as possible. We’re providing plenty of notice and resources to support you along the way. Be sure to visit our community forums – they’re full of helpful tips and advice to guide you through the upgrade process.

Important Dates:

12.0 De-supported (Reminder)

12.1 Support Schedule

13.0 Support Schedule

Preparing for the Next Step

Upgrading to a newer version isn’t just about keeping up—it’s about leveling up. With fresh features and enhancements waiting for you, now’s the perfect time to make the move. Here’s how to get ready:

Explore What’s New: Discover the latest features and improvements we’ve packed into version 13.1. Check out our blog posts for a closer look at all the exciting updates.

Connect With Us to Upgrade: Contact our sales team for a customized upgrade quote. If you purchased your licenses within the past couple of years, you might qualify for a discount—don’t miss out!

Tap Into Community Expertise: Leverage insights from other users in our community forums. You’ll find valuable tips and shared experiences to help make your upgrade seamless.

Get a More Personalized Experience: Our Isomorphic Consulting team is here to help. We’re ready to assist whether you need expert advice, support managing your application upgrades, or a complete Application Modernization to unlock the latest platform features. Don’t hesitate to reach out and let us know how we can support you!

Embracing the Future

Every upgrade is a step toward something better. It’s not just about staying current—it’s about unlocking the full potential of what SmartClient has to offer. Together, we’re ready for the journey ahead and all the possibilities the newest version brings. Cheers to the exciting opportunities that lie ahead!

If upgrading isn’t an option for you right now, but you still need support, don’t worry. Reach out to discuss extended support plans. While upgrading remains the best way to get the most out of the platform, we understand that circumstances vary, and we’re here to help find the right solution for your needs.

There is an ongoing shift in the Java ecosystem from JavaX to Jakarta, which is creating real headaches for developers and software vendors. At SmartClient, we’re stepping up to help our customers navigate these changes with practical tools and clear answers.

We’re excited to share that our upcoming product lineup will bridge the gap between the older JavaX APIs and the newer Jakarta APIs. In this post, we’ll break down what this means and explain how SmartClient is adapting to make Jakarta API transition easier for you.

What happened to Java?

Oracle’s loss in a lawsuit against Google prompted a reorganization of the Java APIs. The reorganization moved classes from the javax namespace to the jakarta namespace. While the functionality remains the same, the reorganization has resulted in incompatibilities between pre-transition (javax) and post-transition (jakarta) APIs.

Our developer forum has been buzzing with discussions about these challenges and their widespread impact on the community. Developers working with platforms like Wildfly and Spring Boot have shared their struggles:

• Teams upgrading to Spring Boot 3.x are hitting roadblocks due to SmartGWT’s reliance on javax imports.
• Wildfly 27 users are stuck because it exclusively supports Jakarta APIs, leaving pre-transition applications unsupported.

Projects dependent on javax APIs face a tough choice: rewrite their code for Jakarta or stick with the old namespace and risk falling behind. Across the globe, organizations are navigating this messy transition, guided largely by their existing dependencies and long-term strategies.

How SmartClient supports the transition from JavaX to Jakarta

Some customers have been desperately asking us for a Jakarta (post-transition) version, and then other customers insist on sticking to the older JavaX (pre-transition) version.  We can’t satisfy both needs with a single version of our product.  Every vendor all over the world has the same dilemma right now (thanks, Oracle).

To address the needs of our diverse developer community, we’re releasing three separate product versions that cater to both API structures:

1. SmartClient 13.1 (JavaX APIs): Designed for developers who continue to use the javax namespace. This version maintains compatibility with pre-transition environments.
   
2. SmartClient 14.1 (Jakarta APIs): Fully aligned with the new jakarta namespace for projects adopting the updated Java APIs.
   
3. SmartClient 14.0NJ (JavaX APIs with 14.0 Features): A transitional release offering javax namespace compatibility alongside the feature set introduced in SmartClient 14.0. This version is available exclusively through a special support plan with Isomorphic Software.

By offering separate versions, SmartClient ensures developers have the flexibility to align with their project’s requirements while maintaining access to our latest innovations.

Hibernate and Spring Compatibility with Jakarta APIs

The transition to the Jakarta namespace has brought changes to widely-used libraries like Hibernate and Spring, which in turn have influenced SmartClient’s integration with these technologies. For Jakarta versions of SmartClient:

• Hibernate: We’re discontinuing support for “beanless mode,” a feature that has consistently been outperformed by our SQLDataSource in terms of speed, simplicity, and flexibility. We continue to recommend SQLDataSource as the best choice for SQL database connectivity. Core JPA/Hibernate features, such as handling DSRequests with AdvancedCriteria, sorting, and paging, will remain fully supported.
  
• Spring: Our focus is on supporting declarative calls to Spring-registered beans, which SmartClient simplifies and optimizes. Other Spring APIs, like Controllers, are being phased out because they add complexity without adding value when SmartClient’s built-in tools are used for REST and service layers.

If you rely on features that are being retired, our Feature Sponsorship program and migration support services can help you retain critical functionality or explore alternative approaches tailored to your project’s needs.

Downloads available now

At smartclient.com/builds:

• 13.1 builds are available now
• 14.1 (Jakarta) builds are available now, but are still marked as “development” builds. These builds are production ready for anyone who is not using Hibernate or JPA, and the “development” designation will be removed in the near future
• 14.0NJ (JavaX APIs) builds are available by special arrangement

SmartClient’s commitment to developers

The transition to Jakarta APIs represents a disruptive but unavoidable chapter in the evolution of Java. At SmartClient, our priority is to ensure that our customers have the tools and support they need to navigate this change successfully.

For more information about how these changes affect your SmartClient integration or to arrange a special support plan for the 14.0NJ version, don’t hesitate to contact us.