Beautifully manage your code's complexity
A new dimension in coding with layers and code-processing.
Universal customization, deep integrations. Teams that works better together - empowering developers and business users alike.

Java transpiler
Reads your code, makes incremental, type-aware changes before compiling (e.g. converting field to getX/setX property)
StrataCode language
Java with properties, data binding, objects, multiple inheritance, templates, and more.
Java to javascript
Robust, efficient Java in the browser. Produces readable, usable Javascript.
Customization with layers
Powerful improvement to object-oriented design without losing static typed integrity.
More declarative apps empowers business and technical user customization.
Data synchronization
Efficient, declarative, debuggable, reliable and manageable client/server applications.
HTML templates
Dynamic HTML templates with flexibility and performance.
Live programming
Live, real-time programming for business and technical users.
Scalable solutions
More efficient model for building and managing custom and customizable forms and applications.

Jeff Vroom ( began realizing the vision for StrataCode ten years ago and is the primary contributor. It's a relatively small, readable, maintainable code base with no core dependencies. StrataCode makes a great build and configuration management tool for your existing Java project. Use the code-processing features and APIs to manage your code with more awareness. Leverage data binding with three new operators: forward, reverse, and bi-directional bindings between properties and expressions. The dynamic Java runtime gives you one language for build files, customized code, configuration and adds an API to create frameworks and tools. Build quick, and customizable management UIs from your domain models. Build apps from scratch with declarative frameworks that leverage the layered pattern, data sync, Java to JS, HTML to Java. Deploy apps as static html/js, server-only or client/server using the same code: fully isomorphic Java. Provides an efficient state model for declarative state lifecycle management: global, per-session, per-window, per-request, multi-tenant, etc.

To get started, StrataCode supports git, maven, and an IntelliJ plugin that integrates well with Java. The test-suite processes code from dozens of standard Java projects, validating type references and catching most errors before compilation.

It's easy to write and debug grammars for new languages and to transform or transpile code. The API lets you make incremental changes to source files by changing properties in the AST objects, or modifying a list property. For example, to change the type name, set the ClassDeclaration.typeName property or to edit the statements of a method, add or remove statements from the MethodDefinition.body property. The IntelliJ plugin is also built on top of this API, using a single declarative grammar to support several languages: scj, sc, schtml, sct, scr, and sccss.

Integrated with HTML/Javascript, Swing, Android, OpenGL, OpenCV, JUnit, Servlets, Jetty, OpenJPA, Hibernate, and Wicket. Designed for rapid and flexible future integrations.

StrataCode's runtime and IDE will be free to download during the trial period but is not yet open source. We are looking for feedback on the right license but we'd like to make an affordable, sustainable developer's tool. If you need something built today, contact Jeff and he'll help you build it better with StrataCode. Although in the early stages, it is already great tool and set of frameworks for building apps from scratch, with a fairly high level of support. It would also be useful to refactor large existing Java code bases, supporting continual evolution during the refactoring process. It can also be used to build or upgrade an existing SaaS platform, or build your own language oriented tools in Java. Extend the IntelliJ plugin, add your own formats and features.

Everyone wants faster software, that takes less work to build and more pleasant to use. StrataCode helps that goal by empowering not only end-users but also back-office employees, administrators, operations, designers, and other people that use and customize the solution. We believe it can empower a new class of applications, built from layered domain models, annotated with layered configuration, driven by management UIs that can reach down into the code for customized rules and operations.

Read more in these articles.