When a Delphi team needs to expose a business application in a browser, the first question is always the same: which web framework? In 2026 there are five credible Delphi-native options: IntraWeb, UniGUI, TMS WEB Core, TMS XData and sgcHTML. Each solves the problem differently, and each shines in a different situation. This post goes through each one honestly, then explains where sgcHTML offers a distinct advantage.
IntraWeb — the original Delphi web framework
IntraWeb has been around since 2001. Its model is straightforward: VCL forms rendered server-side as HTML. If you know Delphi forms, you can build an IntraWeb page. State lives on the server; the browser is essentially a thin display layer. For internal tools with a modest number of concurrent users this approach still works.
Where IntraWeb struggles is theming and modern layout. It generates its own HTML and CSS, which predates Bootstrap and flexbox. Getting a responsive, mobile-friendly page requires significant CSS override work. The generated markup is verbose and hard to integrate with modern design systems. IntraWeb is also entirely stateful: each user holds a server-side session object for the duration of their visit, which limits horizontal scalability.
UniGUI — mature, full-featured, stateful
UniGUI is the most feature-complete Delphi web framework. Its component palette is enormous (grids, charts, trees, maps, file upload, rich-text editor, touch support) and its theming system is mature. Under the hood it uses Sencha ExtJS, a powerful JavaScript component library that produces polished interfaces close to native desktop quality.
The trade-off is complexity and the stateful architecture. UniGUI sessions hold full component state on the server. A busy application with many concurrent users needs significant memory and careful session management. The ExtJS layer, while powerful, is not Bootstrap, which means every new hire who knows Bootstrap needs to learn a parallel vocabulary. Licences are per-developer and per-server, and the per-server component of the licence cost matters for cloud deployments.
TMS WEB Core — client-side Pascal compiled to JavaScript
TMS WEB Core takes the opposite approach: it compiles your Object Pascal application to JavaScript using a WebAssembly-capable compiler. The result runs entirely in the browser; your Delphi form events fire as JavaScript events. The UI uses Bootstrap or Material Design, and TMS WEB Core ships with a growing set of visual components.
This is genuinely clever technology and it works well for certain use cases, particularly self-contained browser applications that need offline capability or very low server load. The limitation is the deployment model. The compiled output is a set of static JavaScript files and assets that must be built, versioned and served. Adding a feature means a rebuild and redeployment of the client bundle. Business logic that previously sat safely on the server now runs in the browser, which raises security questions for sensitive calculations. Integrating with an existing Delphi server-side component (a TsgcWebSocketClient, a FireDAC connection) requires architectural work, because the compiled JavaScript cannot directly call native Delphi units.
TMS XData — REST back end, not a web UI framework
TMS XData is worth mentioning because it is often compared with web UI frameworks, but it is not one. XData generates a REST API from Delphi service classes using OpenAPI 3.0 and JSON. The front end must be built separately — in TMS WEB Core, React, Angular or anything that speaks HTTP. XData is excellent at what it does. It just does not remove the need for a separate front-end technology when you want a browser interface.
sgcHTML — server-side components on standard Bootstrap 5
sgcHTML takes a different position from all of the above. It is a server-side component library whose output is standard Bootstrap 5 HTML. The components themselves are Delphi classes (TsgcHTMLComponent_Chart, TsgcHTMLComponent_DataTable, etc.); you configure them through properties and read a HTML string. That string goes into your HTTP response. The browser renders it using Bootstrap. htmx (a 14 KB library, no build step) handles interactivity: clicks and form submissions return to your Delphi handler, which responds with an HTML fragment, and htmx swaps the relevant section of the page.
The architecture is stateless. Each request builds what it needs, returns the HTML and finishes. There is no per-session component tree to maintain. Horizontal scaling is trivial: put a load balancer in front of two instances of the same .exe.
Side-by-side comparison
| Feature | IntraWeb | UniGUI | TMS WEB Core | sgcHTML |
|---|---|---|---|---|
| Architecture | Stateful server-side forms | Stateful ExtJS session | Client-side Pascal→JS | Stateless server-side HTML |
| Output markup | Proprietary HTML + CSS | ExtJS JSON/HTML | Standard Bootstrap | Standard Bootstrap 5 |
| Interactivity | Full page reload or AJAX | ExtJS AJAX | Runs in browser | htmx fragments + WebSocket |
| Real-time WebSocket push | No (add-on) | Limited | Via JS WebSocket API | Yes — first-class (sgcWebSockets) |
| Scalability | Limited by session state | Limited by session state | Stateless (static files) | Stateless, horizontal |
| JavaScript you write | None | Minimal | None (compiled from Pascal) | None |
| npm / Node.js required | No | No | Yes (build step) | No |
| Single-binary deployment | Yes | Yes | No (JS bundle + assets) | Yes |
| DataSet binding | Yes | Yes | Via JS bridge | Yes (direct TDataSet/TDataSource) |
| Number of UI components | ~40 | 80+ | 50+ | 60+ |
| Mobile/responsive | Partial | Yes (ExtJS Touch) | Yes (Bootstrap) | Yes (Bootstrap 5) |
| .NET edition | No | No | No | Yes (.NET 6+) |
Where sgcHTML has a clear advantage
Real-time dashboards. Because sgcHTML is built on sgcWebSockets, the same server that serves HTML pages also handles WebSocket connections. A stock price update, a new sensor reading, or a completed production run can push an HTML fragment to every connected browser tab in a single Broadcast call. No polling, no separate push infrastructure, no extra licence. IntraWeb and UniGUI both have limited WebSocket support that requires extra integration work. TMS WEB Core can use the browser's native WebSocket API but requires client-side JavaScript logic to handle incoming messages.
Standard markup without customisation overhead. Because the output is Bootstrap 5 HTML, any designer who knows Bootstrap can style it. Themes are standard Bootstrap themes — hundreds of free and paid themes exist and apply instantly. IntraWeb and UniGUI generate framework-specific markup that requires learning a separate styling system.
Stateless and horizontally scalable. Each sgcHTML request is independent. There is no per-user session object on the server. Two load-balanced instances of the same executable serve requests interchangeably. IntraWeb and UniGUI route requests back to the specific server instance that holds the session, complicating cloud deployments.
Single executable deployment. Bootstrap CSS, Chart.js and htmx are embedded resources inside the Delphi binary. Deploying sgcHTML means copying one .exe. TMS WEB Core produces a JavaScript bundle and a set of assets that must be versioned and served separately.
No build chain. There is no npm, no webpack, no Babel and no Node.js. You compile your Delphi project and ship. This matters enormously in regulated environments and on-premises deployments where installing a Node.js toolchain requires IT sign-off.
A direct code comparison: a data grid
To make the difference concrete, here is how to render a searchable, paginated data grid from a FireDAC query, in sgcHTML:
uses
sgcHTML_Component_DataTable;
var
oTable: TsgcHTMLComponent_DataTable;
begin
oTable := TsgcHTMLComponent_DataTable.Create(nil);
oTable.PageBuilder := oPage.PageBuilder;
oTable.Section := 'data';
oTable.Title := 'Customers';
oTable.ShowSearch := True;
oTable.ShowExport := True;
oTable.LoadFromDataSet(fdqCustomers, 25); // 25 rows per page
// Read oTable.HTML and include it in your response
end;The result is a responsive, searchable, paginated Bootstrap table with sort indicators, a search box and an export button. The browser renders it with no additional server round-trips for the initial page. Filtering and pagination use htmx to swap only the table fragment, not the full page.
When to choose the alternatives
sgcHTML is not always the right choice. If you have a large existing IntraWeb or UniGUI application with hundreds of forms and a well-established theming system, migrating it makes little sense. UniGUI is the better choice when you need deep grid capabilities (frozen columns, cell editors, row grouping, pivot) that match or exceed Excel, or when you want the polish of ExtJS for a power-user back-office tool. TMS WEB Core is the right pick when you need an application that runs offline in the browser with no server at all, or when you want to distribute a single-page application as static files through a CDN.
sgcHTML is the strongest choice when:
- You are building a new web interface alongside an existing Delphi back end and do not want to manage a separate JavaScript project.
- The application needs live data pushed from the server (trading screens, logistics dashboards, monitoring, chat).
- You need a responsive, mobile-friendly Bootstrap 5 interface that your team's designers can theme using standard Bootstrap tooling.
- Deployment must be a single executable with no external dependencies.
- You are targeting .NET (C#) alongside Delphi and want the same component API on both platforms.
Trying sgcHTML
A free trial with all 60+ components and no feature restrictions is available at esegece.com/products/sgchtml/download. The download includes four working demo applications (ERP, Admin Console, Live Monitor and Customer Portal) that demonstrate the component palette in realistic scenarios.
Questions or a comparison with a specific existing project? Get in touch. You will get a reply from the people who wrote the code.