Best 4D Forms: Top Picks Compared (2026)

4D Forms are the user interface layer of a 4D application and the platform offers three distinct form types: detail, list and existing output form, each suited to a different task. Getting it right in 2026 means matching the form type to the task, then layering lists of values, subforms, and dynamic properties. This comparison covers practical options, their tradeoffs, and how to decide.

Key Takeaways

• 4D offers three types of 4D forms: detail (one record at a time), list (several records in a grid) and output (print/report layout). Choosing the wrong type is the most common mistake beginners make.
• Project Forms (stored as .4DForm JSON files) are the modern default; Table forms are legacy and linked to a single table. New work should use project forms.
• Dynamic Forms (DIALOG, FORM LOAD, FORM GOTO PAGE) allow you to create and exchange interfaces at runtime - essential for wizard-style flows and role-based user interfaces.
• Value lists (static, hierarchical or from a field/array) drive drop-down lists, combo boxes and pop-up menus; binding them to a field is a single-line property change.
• Subforms embed one form within another and are the standard way to create master-detail layouts without duplicating widgets.
• Performance on list forms is highly dependent on entity selection vs. classic selection and whether lazy loading is enabled for large record sets.

What “4D Forms” Actually Means

4D forms are declarative user interface definitions stored either in the structure (table forms) or as standalone project files (project forms). A form contains objects (input fields, buttons, list boxes, subforms, web areas, and static text) arranged on a canvas with a defined page size and, optionally, multiple pages. Each object carries properties (data source, enterable state, font, coordinates) that 4D evaluates at runtime.

The distinction that matters most for a comparison: a form is not a window. A form is a layout; a window is the container that 4D opens to display it. The same form can appear in a modal dialog box, a palette window, a resizable document window, or embedded as a subform. Understanding this separation allows experienced developers to reuse one form in multiple contexts instead of rebuilding it.

The Three Form Types Compared

Form type	Records shown	Typical use	Key caveat
Detail form	One	Data entry, record editing, dialogs	Needs explicit navigation (buttons, NEXT RECORD)
List form	Many	Browsing, selection, dashboards	Large selections need lazy loading or paging
Output form	Many	Printing, PDF export, reports	Not interactive; layout is print-oriented

Detail forms are the workhorse of data entry. They display the current record of a table and allow users to edit fields directly. A detail form is also the natural choice for a settings dialog or login screen, because you can bind it to no table at all and drive it only with process variables.

List forms present a scrollable grid of records. In modern 4D, list forms are typically built around a list box object rather than the old “list form with columns” approach. List boxes can be array-based or selection-based, and selection-based list boxes bind directly to an entity selection - which is the preferred model when working with ORDA.

Output Forms exist for printing. They render records in a page layout with headers, footers, and break levels. Output forms are not intended for on-screen interaction and 4D will not allow users to tab into fields as they would on a detail form.

Related: Claris FileMaker Pro — The long-running relational database platform for teams that need custom apps on desktop, web, and mobile from a single file..

These are the three primary 4d forms.

Project Forms vs. Table Forms

Project forms are stored as individual “.4DForm” files in the project’s “Forms” folder and are version control-enabled: each form is a separate JSON document, so two developers editing different forms rarely collide during a merge. Table forms are located in the structure file and are edited through the same form editor, but are conceptually linked to a single table.

The practical tips for 2026: Start every new form as a project form. Table forms remain fully supported and you’ll encounter them in legacy databases, but project forms give you clearer differences, easier reuse between tables, and a clearer mental model. Converting a table form to a project form involves moving it out of the table’s form list and into the project’s form list; object definitions are preserved.

Our pick: Airtable — A spreadsheet-simple interface sitting on top of a real relational database, with automations, views, and shareable interfaces..

Building a Form: The Core Steps

1. Create the form in the form editor (Explorer → Forms → New), choosing detail, list or output.
2. Set the page size and, if necessary, add pages for multi-step layouts.
3. Place Objects: Drag fields from Explorer to the canvas or add buttons, list boxes, and subforms from the Object Library.
4. Link Data Sources: Assign each input object to a field, variable, or expression.
5. Configure lists of values for any drop-down list, combo box, or pop-up menu.
6. Wire Events — attach methods to form events (On Load, On Clicked, On Data Change) and object events.
7. Test in the form editor using the built-in preview, then in a running window.

Step 6 is where most of the real work happens when creating 4d forms. A form without event methods is a static image; the On Load form event is typically where you populate arrays, load a list of values, or set enterable states based on the current user’s role.

Value Lists: The Detail That Trips People Up

Value Lists are the mechanism behind every dropdown, combo box, and pop-up menu in 4D forms. There are three types:

• Static lists — you enter values once in the list editor. Ideal for fixed enumerations like status codes.
• Hierarchical lists — supports nested elements with a | separator convention, useful for category trees.
• Dynamic lists — populated from a field, an array, or a formula at runtime. These reflect live data, so a list of active customers remains up to date without redeployment.

A common pitfall: binding a list of dynamic values to a field that stores a reference (an ID) while displaying a label. 4D manages this with the concept of “associated value”: the list stores one value and displays another. Getting it right is the difference between a drop-down list that records “42” and one that records “Acme Corp.”

Subforms and Master-Detail Layouts

Subforms integrate one form into another. The parent form hosts a subform object; the child form displays inside. Data flows through the subform’s “table” property and, in modern 4D, through the Form object passed to the child.

The master detail is the canonical usage for 4D forms: a detail form for an invoice at the top, a list form for invoice lines in a subform below. When the parent record changes, the subform selection is updated — provided you update it in the parent’s On Data Change or by re-binding the selection. Subforms also allow you to create reusable components: a “customer picker” form can be dropped into any parent that needs it.

Dynamic Forms and Runtime UI

Dynamic 4d forms modify the interface while the application is running. The key commands are DIALOG (open a form as a modal or non-modal dialog), FORM LOAD (load a form into memory without displaying it), FORM GOTO PAGE (change pages), and OBJECT SET... which change the object’s properties on the fly.

Related: Knack — A no-code database builder aimed at portals, directories, and internal tools — with flat-rate pricing instead of per-user fees..

Dynamic forms are important for two scenarios. First, Wizard Flows: a single form with multiple pages, advanced by FORM GOTO PAGE as the user completes the steps. Second, role-based interfaces — hide or disable objects at On Load based on user privileges, so that a form serves both an administrator and a read-only viewer. The tradeoff is complexity: dynamic behavior is harder to debug than a static layout, so reserve it for cases where a second form would otherwise be necessary.

Performance Considerations

The performance of 4D forms list forms is dominated by the number of records that 4D must materialize. A selection-based list box linked to an entity selection only loads the rows it displays, which keeps memory flat as the table grows. Classic array-based list boxes load everything in advance and will slow down noticeably on large tables.

Two other levers: lazy loading on list boxes (retrieving rows when scrolling) and server-side queries which return a bounded selection rather than the entire table. For client-server deployments, the round-trip cost of fetching records across the network typically dwarfs the rendering time, so narrowing the selection is the highest-value optimization.

If you are shopping: Zoho Creator — A low-code app builder that plugs into the wider Zoho suite and prices per user rather than per app..

How to Decide

• Data entry for one record? Detailed form.
• Browse or select from many records? List form with a list box based on selection.
• Printing or PDF output? Output form.
• Reusable on multiple tables? Project form, not table form.
• Multi-step process? A form with multiple pages, dynamically advanced.
• Master-detail relationship? Detail form hosting a list form subform.
• Fixed choice set? List of static values. Live data? Dynamic list of values.

These options help you choose the right 4d forms for your needs.

Learning Resources

The official 4D documentation is the authoritative reference for 4D forms, objects, events and commands. Start there to find out the exact property names and command signatures. For background on the underlying database concepts, the Wikipedia article on 4D (software) gives a useful history of the platform. The JSON format page is worth reading if you plan to edit the .4DForm files by hand or compare them in version control. For general relational design principles that inform how you structure the tables behind your forms, check out the database normalization overview.

Frequently Asked Questions

What is a 4D form?

A 4D form is a declarative user interface presentation composed of objects (input fields, buttons, list boxes, subforms) linked to data sources. 4D evaluates the form’s properties at runtime and displays it in a window, a dialog box or as an embedded subform. Forms are of three types: detail, list, and output.

What is the difference between a detail form and a list form in 4D?

A detail form displays one record at a time and is used for data entry and editing. A list form displays many records, usually in a list box, and is used for browsing and selection. The two are often combined: a list form to choose a record, then a detail form to edit it.

Should I use project forms or table forms?

Project forms are the modern standard by default and are stored as separate “.4DForm” files, making them easier to reuse and manage in version control. Table forms are legacy and linked to a single table. New development should use project forms; table forms remain supported for existing databases.

How do value lists work in 4D forms?

Value lists populate drop-down lists, combo boxes, and pop-up menus. They can be static (entered only once), hierarchical (nested items) or dynamic (created from a field, array or formula at run time). A value list can store one value while displaying another, which is how you display a customer’s name while saving their ID.

Can I change a 4D form at runtime?

Yes. Dynamic forms use commands such as DIALOG, FORM LOAD, and FORM GOTO PAGE to load forms, switch pages, and change object properties while the application is running. This supports wizard-style flows and role-based interfaces where one form serves different users.

Why is my 4D list form slow with large tables?

The slowness of the list form generally comes from materializing too many records. Selection-based list boxes linked to entity selections load only the displayed rows, while array-based list boxes load everything. Enabling lazy loading and narrowing the query to a bounded selection are the two fixes with the biggest impact.

P.S. A few readers have asked which low-code app builder we actually reach for — it's Zoho Creator; take a look here if you want the current details.