Pull requests are welcome. Tests first.

RustCFML is MIT-licensed and developed in the open. The bar for a change is simple to state and hard to game: your test has to pass on Lucee. That single rule is what keeps a volunteer-built engine from drifting into a dialect.

Open an issue Open pull requests

Four things worth knowing before you start

Open an issue before a pull request

Especially if you have not contributed here before. A minimal reproducible CFML snippet, what you expected and what actually happened is worth more than a diff. It turns a guess into a shared understanding of the bug.

The test is the contribution

The preferred fix is a CFML-based test that demonstrates the behaviour. Once the engine passes it, the fix is usually small, and the test is what stops the bug coming back in the next refactor.

It must pass on Lucee

Lucee is the reference implementation and cfdocs.org is the compatibility target. If your test does not pass on Lucee, it will not be accepted, with rare exceptions where Lucee allows something genuinely unreasonable.

The core stays lean

Features that churn in the wider ecosystem belong in libraries, and features that belong in your pipeline do not belong in a runtime. If a proposal is really a CI/CD feature, the answer will be a friendly no and a pointer to .rcx extensions.

A test that reads like a bug report

Tests are written in CFML, which means anyone who can write a template can write a regression test, and the same suite is run against Lucee so compatibility is a measured claim rather than a badge. There is no test framework to install and nothing to learn: a small harness in the repository gives you suiteBegin(), assert(), assertTrue(), assertFalse(), assertNull(), assertThrows() and suiteEnd(), and the rest is ordinary CFML.

  • Reproduce the gap first, in the smallest template that shows it
  • Name it tests/<category>/test_<feature>.cfm and register it in tests/runner.cfm with <cf_runtest>
  • Run cargo run -- tests/runner.cfm, then the same runner against Lucee over HTTP
  • Reference the cfdocs page if the function is documented there
  • If you touched a dependency, regenerate the licence attribution

Full instructions in docs/testing.md.

tests/stdlib/test_reduce_empty_array.cfm
<!--- reduce() over an empty array with no initial value
      should throw, not return an empty string.
      cfdocs.org/reduce · measured on Lucee 7.1.0.204. --->
<cfscript>
suiteBegin( "stdlib: reduce over an empty array" );

_nums = [ 1, 2, 3 ];

assertThrows( "no initial value on an empty array", function () {
    return [].reduce( ( acc, n ) => acc + n );
} );

// assert( label, actual, expected )
assert( "an initial value comes back untouched"
    , [].reduce( ( acc, n ) => acc + n, 10 ), 10 );

// And the happy path is unchanged.
assert( "sums from an initial value"
    , _nums.reduce( ( acc, n ) => acc + n, 10 ), 16 );

suiteEnd();
</cfscript>

The engine is not the only thing that needs work

Documentation

The docs live beside the code. A page that says exactly where a feature stops working saves the next person an afternoon, and needs no build step.

Reproducible issues

The fastest issues to close are the ones with a twelve-line template, an expected result and an actual result. Divergences from Lucee are especially useful.

Port an application

Take a real CFML application you own, run it on RustCFML, and report what broke. Migration reports are how compatibility gaps get prioritised.

Benchmarks

Numbers from someone else’s machine are a hypothesis. Pull the benchmark suite, run it on your hardware and open an issue when you beat us.

Who is in here

RustCFML started as one person’s experiment in what models could build, and it is now an open repository with contributors filing issues, writing tests and sending patches. Avatars are generated from the GitHub contributor graph, so this list is never out of date.

Contributor graph Discussions
RustCFML contributors

Avatars from the GitHub contributor graph, generated by contrib.rocks.

Three projects this would not exist without

None of their code is in this binary. All of their decisions are.

Reference implementation

Lucee

The open-source CFML engine in Java, and the compatibility target every test here is run against. Where behaviour is in doubt, Lucee decides.

Contemporary

BoxLang

A modern CFML+ runtime on the JVM, and the honest second entry in the query-of-queries benchmark table.

Architectural

RustPython

A Python interpreter in Rust, and the shape this project took: same language, new plumbing, no host VM.

ColdFusion® is a registered trademark of Adobe Inc. RustCFML is an independent implementation, is not affiliated with or endorsed by Adobe, and ships no Adobe code.

Start with an issue, not a fork

Tell us what you expected and what happened, with the smallest template that shows it. That is the contribution that starts everything else.

Open an issue How the tests work