Oracle Forms to Java -
Fully Automated.
Complete. Safe.
Re_Forms21® transforms Oracle Forms to modern, cloud-ready Java with full automation — preserving every trigger, every business rule, and every data flow. No manual rewrites. No downtime.
supported
migration
preserved
Re_Forms21® Has the Best Migration Coverage on the Market
The migration scope is not aspirational – it is what the platform supports today, validated against real enterprise Oracle Forms applications.
Re_Forms21® has the best migration coverage on the market
The migration scope is not aspirational. It is what the platform supports today, validated against real enterprise Oracle Forms applications.
- All module types. FMB, MMB, PLL, OLB, RDF* — the full Oracle Forms ecosystem, including menus, libraries, object groups, and reports.
- Almost all Oracle Forms triggers. 120+ trigger types — covering the full WHEN-, KEY-, PRE-, POST-, and ON- families.
- Almost all UI widgets. Standard Forms widgets are migrated 1:1. UI beans are the only category not supported, and are flagged early in the assessment.
- All major built-in PL/SQL and Forms procedures and functions. The behavioral library is preserved — not approximated — in the generated Java.
- SQL-like Java types. SqlVarchar, SqlRecord, SqlTableOf, SqlCursor — a dedicated type system that mirrors PL/SQL semantics directly in Java.
Unique SQL-Like Java Features
The Re_Forms21® type system bridges PL/SQL and Java directly — so the generated code feels like Java to engineers, but behaves like PL/SQL where it matters: parameter passing, NULL semantics, and operator compatibility.
A Four-Step Pipeline.
No Hand-Coded Logic.
The transformation is not a generator that produces a starting point. It produces the running Java backend — equivalent to the Oracle Forms source by construction.
Assignment by Value (Not by Reference)
SQL-like Java types follow PL/SQL value semantics — not Java reference semantics — so assignments behave the way the original code expects.
Automatic Variable Initialization
No manual ceremony. Variables initialize automatically with the correct PL/SQL-equivalent default state, including NULL where applicable.
Automatic Conversion from Common Java Types
Interop with regular Java is built in. Common Java types convert cleanly into the SQL-like equivalents — no boilerplate plumbing for engineers.
IN, OUT and INOUT Parameters Handling
The full PL/SQL parameter mode model is preserved at the call boundary — IN, OUT, and INOUT — not flattened into Java reference passing.
Three-Valued BOOLEAN
TRUE, FALSE, and NULL are all first-class states — just like Oracle. The behavior of conditional logic involving NULLs is preserved end-to-end.
Compatibility with Java Operators
Unlike BigDecimal, SQL-like Java types work with native Java operators — + − * / ==. Arithmetic expressions remain readable.
What Extra Do You Get from Re_Forms21®?
Beyond full migration coverage, Re_Forms21® adds built-in capabilities that eliminate the most common gaps between Oracle Forms behavior and the new Java application — from day one.
Default Trigger Code
Auto-generated implementations for ON-POPULATE-DETAILS and ON-CLEAR-DETAILS — covering the most critical default trigger behavior automatically.
One-Attribute Look-Ups
Look-ups generated automatically from Oracle Designer look-up definitions. The entire Oracle Designer look-up mechanism is preserved and transformed without manual mapping.
Built-In Calendar
A ready-to-use date picker matching Oracle Forms date input behavior — no third-party library required, fully consistent with the migrated application's data model.
Customizable Runtime Alerts
Alerts that can be created and customized at runtime — matching the Oracle Forms ALERT behavior. Business users can modify messages without developer involvement.
Dynamic Layouts
Form layout is fully dynamic and server-controlled. Blocks, items, and canvas elements can be shown, hidden, and resized at runtime — just as Oracle Forms allowed via PL/SQL trigger code.
ReForms21 Studio
A visual development environment similar to Oracle Form Builder. Plus: "no freeze" development — re-migration is fully automatic when Oracle Forms requirements change.
Re_Forms21® vs Oracle Forms Architecture
See how the Re_Forms21 architecture streamlines and modernizes your Oracle Forms. Compare the legacy model with a future-ready solution designed for flexibility, scalability, and performance.
AI-Driven Leader in Oracle Forms Migration
At ReForms21™, we deliver fully automated modernization of Oracle legacy systems that guarantees 100% preservation of business logic and seamless continuity of operations. Building on years of innovation, we’ve recently introduced AI and Large Language Models (LLMs) to redefine how legacy systems are transformed.
Automated Analytical Documentation
High-quality documentation and test scenarios are generated automatically using an LLM model trained on Oracle Forms semantics, closing a long-standing gap for most legacy owners and minimizing support from your technical teams.
Interactive Code Migration
An AI-assisted migration engine translates PL/SQL and Oracle Forms directly into modern Java architecture, ensuring clean, standard-compliant code with minimal manual intervention — even for complex non-standard trigger logic.
Smarter Database Migration
Leveraging LLMs, Re_Forms21® can complete missing code and streamline migration as well outside Oracle DB environment if needed, dramatically reducing time and costs compared to traditional approaches.
migration rate
preserved
during migration
types supported
These innovations position ReForms21™ as the AI-driven leader in Oracle Forms and Reports migration — ensuring faster, safer, and more cost-effective migrations while keeping mission-critical systems running without disruption.
The Digital Twin of Your Application.
RIB is the central reasoning engine of the ReML suite. It performs forensic static analysis — automatically ingesting source code and database schemas to construct a fully integrated architecture graph of your entire system. Not a summary. A structural map.
What RIB Gives You That No Documentation Can
These are not theoretical risks. They are the failure modes we observed across the analysis of over 76 million lines of Oracle Forms code.
Forensic Static Analysis
Automatically ingests source code and database schemas. Maps every form block, trigger, procedure, package, and table relationship into a unified dependency graph — without requiring any manual annotation.
Deterministic Impact Analysis
Know exactly which procedures, packages, or UI components will be affected by a database change. The system traces data lineage from the interface down to the deep PL/SQL logic — before a single line of code is written.
Living Documentation
Functional specifications that stay synchronized with the running system and database structures. When the code changes, the documentation changes. No manual updates. No drift between spec and reality.
Guided PL/SQL → Java Migration
An AI-assisted workflow for extracting logic from the database into maintainable Java code. Preserves the original developer's intent while ensuring the new code meets modern enterprise standards — and validates against the RIB graph.
Video tutorials
From Oracle Forms to Java in practice — demos, deep dives, and before/after sessions. Learn how we keep logic intact while unlocking cloud-ready architecture.
Tutorials
Trigger Logic Transforms.
It Does Not Get Reinvented.
A simplified, schematic view of how a single Oracle Forms trigger is transformed into idiomatic Java with 3VL preserved. Real production output is more comprehensive — this is the structural shape.
PACKAGE EMP_PKG IS PROCEDURE fill_job_name; END;
PACKAGE BODY EMP_PKG IS PROCEDURE fill_job_name IS CURSOR lookup_job IS SELECT job_title FROM jobs WHERE job_id = :EMP_BLOCK.JOB_ID; BEGIN OPEN lookup_job; FETCH lookup_job INTO :EMP_BLOCK.JOB_NAME; CLOSE lookup_job; END; END;
TRIGGER "WHEN-NEW-FORM-INSTANCE" IS BEGIN Execute_Query; END "WHEN-NEW-FORM-INSTANCE";
TRIGGER "POST-QUERY" ON EMP_BLOCK IS BEGIN EMP_PKG.fill_job_name; END "POST-QUERY";
@FormController("EXAMPLE1") public class Example1Form { @Inject EmpPkg emp_pkg; public static abstract class EmpPkg { public abstract void fill_job_name(); }
@Package public class EmpPkgBody extends EmpPkg { public void fill_job_name() { SqlCursor<?> lookup_job = cursorFor( "SELECT job_title FROM jobs WHERE job_id = :EMP_BLOCK.JOB_ID" ); try { open(lookup_job); fetchInto(lookup_job, nameIn("EMP_BLOCK.JOB_NAME")); } finally { if (lookup_job.isOpen()) { close(lookup_job); } } } }
@WhenNewFormInstance public void form_WHEN_NEW_FORM_INSTANCE() { executeQuery(); }
@PostQuery("EMP_BLOCK") public void block_EMP_BLOCK_POST_QUERY() { emp_pkg.fill_job_name(); } }
Your Demo
We modernize a representative form to web-native Java and show it live. Same logic, cleaner UI, ready for CI/CD — so you can decide with evidence, not promises.

Demo Oracle Forms
username: rf21
password: rf21
CAUTION: this is a legacy technology.
Demo works only on Internet Explorer with Java



Cloud Re_Forms21®
After migration of Oracle Forms technology to modern Java technology, the new application can run in any cloud, offering additional benefits that were impossible with Oracle Forms on-premises.
No Expenses Related to Hardware Infrastructure
Eliminate all costs related to the purchase and maintenance of Oracle Forms server hardware. The Java application runs on standard JVM infrastructure available from every major cloud provider at a fraction of the cost.
Virtually Unlimited Expansion and Scalability
Cloud backup of application and database servers offers virtually unlimited scalability — adapting to seasonal demand spikes or organizational growth without manual infrastructure provisioning.
Automatic Backup and Restore in Case of Failure
Cloud infrastructure provides automatic backup and restore — replacing the manual Oracle Forms backup procedures with cloud-native reliability guarantees and defined RPO/RTO targets.
Hybrid Model Option — App in the Cloud, Database On-Premises
Run the Java application in the cloud while keeping the database on-premises. The hybrid architecture supports organizations with data residency requirements, compliance constraints, or phased migration strategies.