the fastest way to reach us:

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.

 

0 +
Trigger types
supported
0 %
Fully automated
migration
0 %
Business logic
preserved
0 %
Downtime during
migration

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® — coverage matrix
Module types
All
FMB · MMB · PLL · OLB · RDF*
Oracle Forms triggers
120+
Almost all trigger types
UI widgets
Almost all
UI beans are not supported
Built-in PL/SQL
Major
Procedures & functions covered
SQL-like Java types
Full
SqlVarchar · SqlRecord · SqlTableOf · SqlCursor
The result: a transformation that handles the structural depth of Oracle Forms — not just the surface. Every trigger family, every module type, every PL/SQL built-in is part of the automated migration model.

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.

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.

 

forms-to-java.transform.pipeline
Ingestion sources
.fmb / .fmx
Oracle Forms files
PL/SQL packages
Procedures & triggers
DB schema
Tables, views, sequences
Library .pll
Shared form libraries
↓ structural transformation ↓
ReForms21 Transformation Engine
trigger-aware · SQL types · Java emission
↓ produces ↓
Java output
Java Domain & Service Layer
@FormController, @Package, trigger handlers
SqlVarchar / SqlRecord types
Three-valued logic · cursor support
Behavioral Equivalence Report
Auto-generated
Trigger Hierarchy Preserved
The Java backend retains the precise firing order of Oracle Forms events — Pre-Insert before WHEN-VALIDATE-ITEM before POST-CHANGE — so behavioral equivalence is not approximated, it is structural.

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.

 

Presentation Execution environment Database Development ORACLEFORMS Re_Forms21® Web Browser Java Applet WebLogic / IAS ORACLE FORMSApplication FMX MMX PLX ORACLE FORMSRuntime ORACLE FORMSBuilder PLL FMB MMB OLB ORACLEDATABASE Web Browser HTML5 + JavaScript JEE Application Server Java Web Application (WAR) Re_Forms21®Library vaadin Re_Forms21®Application CLASS RFXML Re_Forms21®Studio (Eclipse) JAVA RFXML Oracle Forms Compiler (frmcmp) migration WebSocket JDBC Maven

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.

Re_Forms21® — migration outcomes
99%
Fully automated
migration rate
100%
Business logic
preserved
0%
Downtime
during migration
120+
Oracle trigger
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.

RIB — architecture-graph.analysis
.fmb / .fmx
Oracle Forms files
PL/SQL packages
Procedures & triggers
DB schema
Tables, views, sequences
Java/React source
Migrated codebase
↓ forensic static analysis ↓
RIB Core — Architecture Graph Engine
Cross-layer data flow mapping · Dependency resolution · Impact tracing
↓ generates ↓
Full Architecture Graph
UI → PL/SQL → DB lineage map
Deterministic Impact Analysis
Change X → affects Y, Z, W (before coding)
Living Documentation
Always synchronized with running system
IDE Integration via MCP
RIB feeds authoritative architectural context directly into AI assistants (Copilot, Cursor) inside your IDE — ensuring AI-generated code is grounded in your project's specific rules, not generic patterns.

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

4 Videos

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.

 
PL/SQL





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";
Java
@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

Generic Re_Forms21® Demo

username: rf21
password: rf21

Modern Re_Forms21® Demo

username: rf21
password: rf21

Re_Forms21® Demo in Vaadin​

username: rf21
password: rf21

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.

Fully Automated
Migration (99%)

Oracle Forms
and Reports to Java

Preserves 100%
of Business  Logic & UI

Open Path
to any cloud

ZERO DOWNTIME
of your operations

Get your Proof of Concept.
Don’t wait!

Thank you for filling out the form!

Freely download Re_Forms21 Reports Tool to evaluate reports and estimate prices. So easy! Stop waiting!

To download your analyser, fill out the form: