Wheels-The Fast &
Fun
CFML Framework!
Build apps quickly with an
organized, Ruby on
Rails-inspired
structure.
Get up and
running in no time!
Automatic Documentation
Use our built in doc viewer which grows with your application with only minor markup required
Full Documentation
Lots of lovely documentation available with tutorials and a complete API reference
Latest From the Wheels Dev Blog
CFWheels 1.4.5 maintenance Release
Bug Fixes
- Display URL correctly in error email when on HTTPS - [Per Djurner]
- Added the datetimeoffset data type to the Microsoft SQL Server adapter - [Danny Beard]
- Fix for test link display in debug footer - #588 [Tom King]
- Don't include query string when looking for image on file through imageTag() - [Per Djurner]
- Format numbers in paginationLinks() - [Per Djurner]
- Correct plugin filename case on application startup - #586 [Chris Peters]
- Clear out cached queries on reload - #585 [Andy Bellenie]
ColdFusion on Wheels 1.1.4 released
View Enhancements
- Allow an array of structs to used for options in
selectTag()
- Added
secondStep
parameter to date/time select tags
Model Enhancements
- Update to
belongsTo()
,hasOne()
andhasMany()
for the new argumentjoinKey
. - You can pass an unlimited number properties when using dynamic finders
- Dynamic finders now support passing in an array for values
- Added the
delimiter
argument to dynamic finders, this allow you to change the delimiter - Added
validationTypeForProperty()
method
Other Enhancements
- Added proper HTTP status headers
- Plugin development no longer requires a zip file
Bug Fixes
- Incorrect MIME type for JSON
- Route with format will cause exception when route is selected and format is not provided
- Raise
renderError
when template is not found for format labelClass
should split up the list of classes and attach one class for each label- Transactions would not close when used with the
dependent
argument ofhasMany()
- Soft deletes do not work correctly with outer joins
- Better error message when supplying a query param of type string and omitting single quotes
- Allow commas in dynamic finders
- AMPM select displaying twice
$request
argumentsCollection
: should beargumentCollection
- Pagination pull incorrect number of results with compounded keys
- Update
hasChanged()
to properly check floats - Date tags selected date throws out of range error
ColdFusion on Wheels is moving to GitHub
Calling all plugin authors! Time for 2.x...
With CFWheels 2.0 beta around the corner, it's time to have a cold hard look at the CFWheels plugin ecosystem. With 2.x, we've taken the opportunity to modernise how we deal with plugins. If you're a plugin author who has previously released something for 1.x, you'll be pleased to hear there aren't that many changes required to get your plugins playing nicely with 2.x, but it's definitely a good time to revisit what you've got out there.
Introducing Forgebox.io
One of the main problems we had previously was a lack of a centralised repository of CFwheels plugins. The old system relied on a bit too much manual updating, and over time got a little long in the tooth. So now, all plugins should be added to forgebox.io, specifically in the CFWheels Plugins
category. If you go and have a look now, you'll see a few added by the core team as examples. Adding your plugin shouldn't be too much hard work, but it's definitely worth setting yourself up properly to publish to forgebox automatically via the commandline. There's an extensive tutorial over at guides.cfwheels.org which we recommend you follow. In short, you ideally need a properly configured box.json
file and for your plugins to use git tagged releases (ideally). If you've not installed commandbox and the CFWheels CLI, now is definitely the time to try it!
Easier for other developers too
Once your plugin is in the forgebox system, other CFWheels users can install your plugin with a single CLI command: install slugName
; If they've got the CFWheels CLI installed, it will automatically create appropriate .zip
files with the correct version number (which you'll have set in box.json
) too. They'll also be able to view all existing plugins with wheels plugins list
making it extra quick to find the plugin they need. Dependencies are then tracked in that user's box.json
file, so they can even distribute an app without your plugin, and then simply run install
to go and download the correct version later: they can even update to the latest version of your plugin via the CLI too, or freeze it to a specific version.
Automatic Java Mappings
One of the nice new features of 2.x is the automatic java library mappings which plugins can now take advantage of. Previously, you had to rely on the developer to manually add an entry into this.javaSettings.loadpaths
if your plugin required use of a .class
or .jar
file. Now, we scan the plugin folders on startup, and automatically add any folders which contain .jar
or .class
files. One less step for configuration! You can see an example of this in the CFWheels bCrypt plugin, which adds a quick wrapper around the bCrypt java class.
Don't forget your comments!
In a previous post, we talked about the new embedded documentation: plugins can now take advantage of this. For plugin authors, we're recommending you comment all public functions - here's a quasi code example below. https://gist.github.com/neokoenig/d149a75aa69b8cac49464ffc12f19027 The important part is the [section: Plugins]
and [category: Plugin Name]
part, which will automatically sort your functions in the correct place in the internal documentation. It's a good habit to get into, and will help other users of your plugin too.
Oh, and unit tests :)
Don't forget to write some unit tests too (hey, don't we all do TDD?); there's been some changes to the test suite in 2.x, and writing unit tests is loads easier. More to follow on:
- New functions for testing in 2.x
- Running plugin tests via command line,
- How to add your plugin to Travis CI for continuous integration testing
T-shirt and Hosting Giveaways at CFUnited 2010
- ColdFusion on Wheels - Convention Over Configuration
- Simplifying Database Code with the ColdFusion on Wheels ORM
- BOF: CFWheels - Finally, a Framework for the Rest of Us
CFWheels 2.3.0-rc.1 Released
This version has been cooking for a while and there have been many contributors. But since this is my first release a the helm with a new CI pipeline in place, I felt more comfortable doing a Release Candidate first.
If updating from CFWheels 2.2.x:
If should be an easy upgrade, just swap out the wheels
folder.
Changelog
View Enhancements
- Adds association error support via
includeAssociations
argument #1080 - [Nikolaj Frey]
Bug Fixes
- onerror handler should increase user defined requestTimeout value #1056 - [Adam Chapman]
- deletedAt should also respect timestamp mode (UTC) #1063 - [David Belanger]
- Fixes No output from
Debug()
usage in plugin test cases #1061 - [Tom King] - Development mode will now properly return a 404 status if view not found #1067 - [Adam Cameron, Tom King]
- 404 status now properly returned without URL rewriting #1067 - [Adam Cameron, Tom King]
- Internal Docs in ACF2018 should now not display duplicate categories [Tom King]
- Internal Docs search now resets itself properly on backspace with empty value #982 - [Brandon Shea, Tom King]
ValidatesConfirmationOf()
now correctly enforces prescence of confirmation property #1070 - [Adam Cameron, Tom King]resource()
/resources()
now allows emptyonly
property to utilise as non-route parent #1083 - [Brian Ramsey]- Handle XSS Injection in development enviroment - [Michael Diederich]
- Fix params bug in CLI API [#1106] - [Peter Amiri]
Miscellaneous
- Update Docker Lucee Commandbox version to 5.2.0 - [Adam Chapman, Tom King]
- Minor internal obselete reference to modelComponentPath removed - [Adam Chapman, Tom King]
- Minor visual fix for long migration logs overflow in modal (scroll) - [Brian Ramsey]
- Add test suite for Lucee and H2 Database to the GitHub Actions test suite. - [Peter Amiri]
- On going changes to update the H2 drivers [#1107] - [Peter Amiri]
- Fixes some syntax formating introduced by cfformat [#1111] - [Adam Chapman]
- Minimum ColdFusion version is now ColdFusion (2018 release) Update 3 (2018,0,03,314033) / ColdFusion (2016 release) Update 10 (2016,0,10,314028) / ColdFusion 11 Update 18 (11,0,18,314030) #923 - [Michael Diederich]
- Wheels save(allowExplicitTimestamps=true) doesn't produce the expected result [#1113] - [SebastienFCT]
Potentially Breaking Changes
- Automatic Time Stamps: the deletedAt column was using the server's local time for the timestamp while createdAt / updatedAt were using the timestamp selected for the timestamp mode. The default for CFWheels' timestamp mode is UTC and therefore all future deletedAt timestamps will be in UTC unless you've changed the default. Please review any SQL that uses deletedAt for datetime comparison.
Starting the 2nd beta of ColdFusion on Wheels 1.1
Starting a New CFWheels Project with the CLI
If you're not using CommandBox for your CFWheels development, you're in for a treat. This is a quick post to show case how easy it is to start a new CFWheels project with the help of the the wheels
command for CommandBox.
If you have CommandBox installed and have the cfwheels-cli
module installed, then simply launch CommandBox by typing box
and then issue the command wheels generate app myApp
. This simple command will take care of the following:
- Create a folder in the current working directory for the project and name if myApp
- Copy the
cfwheels-template-base
package from ForgeBox and expand it in the root of the myApp folder - Copy the
cfwheels-core
package from ForgeBox and expand it into the wheels folder in the root of the myApp folder - This command also takes care of naming your app myApp or whatever name you pass in
You may be asking yourself, what are all these packages you're talking about? Well, we are starting to use the package management system provided by ForgeBox and CommandBox to make distribution of sample apps easier as well as installing and updating projects based on CFWheels. More to come on these topics later but this is just to whet your appetite.
Come Get Your Fresh 0.7 Release!
Creating a Basic CRUD Interface with Wheels 3.0
Accompanying Video
This blog post has an accompanying video posted to YouTube.
Welcome to the next installment in our Wheels 3.0 tutorial series! Today, we’ll guide you through creating a basic CRUD (Create, Read, Update, Delete) interface using the Wheels CLI. If you're just joining us and don't have the Wheels CLI installed yet, be sure to catch up with our previous video detailing the setup of your development environment.
Setting Up Your Wheels Project
To get started, we activate the `WHEELS NEW` command, which launches a wizard designed to help us build a new Wheels project efficiently. First, provide a name for your application—I'll be using "myapp" as the demonstration name.
During the setup, you'll be prompted to select which Wheels version to install, and we’ll choose the second option for Wheels 3.0. For development purposes, we'll leave the reload password empty, but remember to set a secure password before moving to production. Next, the wizard will ask for a datasource name, which defaults to our application name and suits our needs.
You’ll then be asked to select a CFML engine for deployment, and we’ll stick with the default, the latest version of Lucee. Since we opted for the Lucee engine, it offers the use of a built-in H2 database—a great development option that avoids setting up a separate database server. We’ll go ahead and select “yes” to use it.
You'll have the option to include the Bootstrap CSS framework to enhance the appearance of your app. Finally, decide whether you want a box.json file for uploading the project to Forgebox.io. For this project, I’ll choose “no.”
After confirming our settings, the wizard will download the specified 3.0 template, along with any necessary dependencies, setup the H2 database, integrate Bootstrap, and start the server. Once the installation is complete, we can explore what’s been set up.
Exploring the CLI Setup
The CLI generates a default Wheels installation skeleton, which it modifies based on our inputs, such as updating configuration files and creating essentials like the URL rewrite file and a server.json file.
Upon successful installation, the confirmation screen assures us with a set of configurations displayed on the Info tab. This includes details like application and datasource names, and confirms the H2 database driver installation with the ready-to-use datasource.
Creating a User Model
Now, it’s time to create users through the CLI. In CommandBox, we use the `wheels scaffold` command to begin creating a User model. We’ll bypass the database migration initially but note how this step has generated skeleton view files, a model file, and a controller in the app. This default setup is crucial for the business logic and user interactions.
To give the user model some structure, we use the command line to add properties like first name, last name, and email to the User model, although we'll skip database migrations for these incremental property additions.
Consolidating Migration Files
Before executing database migrations, it’s wise to consolidate the migration files generated. Inside the app's migrator/migrations folder are several CFC files. We aim to merge these into a single file, ensuring the `up` and `down` functions are properly matched—creating a table in `up` and dropping it in `down`.
Once consolidated, enhance the migration script by adding string-based columns for first and last names with a character limit, and a longer limit for emails, ensuring database integrity and conformity.
Running Migrations
Migrations can be executed via the CLI or the application's user interface. Using the UI, navigate to the Migrator tab and run the migrations in sequence or opt for 'Migrate to Latest’ to process all migrations.
Given that model configurations are cached, reload the application post-migration to let the framework update model configurations based on new database structures.
Finalizing the Application
Lastly, make the User index the default application page rather than the Congratulations page. Modify the routes.cfm file to direct URLs to the users index route by default. Reload the application to apply this routing change, and upon revisiting the default route, the Users page should now load by default.
This tutorial concludes our hands-on exploration of CRUD interface creation in Wheels 3.0 using CLI. We covered project setup, database configuration, scaffolding models, property additions, migration management, and front-end interfacing—all culminating in a functional application displaying user data.
Welcome to Our Community
Welcome to Our Community - a place where like-minded people connect, share ideas,
and grow
together in a positive and supportive environment.

This website uses essential cookies to improve your experience. By continuing to use the site, you consent to the use of cookies.
Top Contributors
Per Djurner
Contributed as a Software Developer
Per Djurner is a long-time core contributor and leader of the Wheels framework, with a history of shaping its direction since the project’s early days. He made the very first commit and has continued to contribute regularly, fixing important bugs, refining SQL handling, and enhancing model methods with more flexible options. In addition to code, he has improved documentation, templates, and overall project stability, ensuring Wheels remains reliable and developer-friendly. His work reflects both technical expertise and long-term commitment to the growth of the framework.
Peter Amiri
Contributed as a Software Developer and Project Manager
Peter Amiri is a senior developer and community leader who has taken on a core team / maintainer role in the Wheels framework. He has decades of experience with ColdFusion (since version 1.5), including work in user-groups, large scale sites, and infrastructure. Since returning to the project, he’s helped revitalize it — organizing roadmap discussions, guiding structure changes, supervising modernization (including CLI improvements, package modularization, and updating workflows), and helping re-energize community contributions.
Zain Ul Abideen
Contributed as a Software Developer
Zain Ul Abideen is an active contributor to the Wheels framework, playing a key role in improving its stability and usability. His work includes fixing issues like invalid columns not throwing exceptions, ensuring primary keys return correctly as numeric, and refining logic around calculated properties. He also enhanced view helpers to better handle active states and improved default routing behavior. Through these contributions, Zain has strengthened both the framework’s reliability and developer experience.
Anthony Petruzzi
Contributed as a Software Developer
Anthony Petruzzi has made valuable contributions to the Wheels through code improvements, bug fixes, and collaborative reviews. They’ve helped refine core components, enhanced framework stability, and actively participated in issue discussions to steer design decisions. Their efforts in writing clear, maintainable code and offering constructive feedback in pull requests have strengthened the project’s code quality. Overall, Anthony Petruzzi involvement showcases dedication to open-source collaboration and meaningful impact on the Wheels ecosystem.
Tom King
Contributed as a Software Developer and Maintainer
Tom King is one of the core maintainers of Wheels, with deep involvement in both development and leadership. He oversaw major releases, such as Wheels 2.0, which introduced features like RESTful routing, database migrations, improved CLI support, and a rewritten core in CFScript. He also helps steer the project’s long-term direction — writing blog posts reflecting on its history (e.g. noting its first commits, celebrating milestones) and working to modernize both tooling and community engagement.
Adam Chapman
Contributed as a Software Developer
Adam Chapman has been a dedicated and influential contributor to the Wheels ecosystem. He joined the core team after years of community support, helping to steer architectural evolution and plugin integrations. Beyond code, he’s actively engaged in issue triage, proposing enhancements and shaping long-term design direction. His commitment to both community discussion and technical contributions has strengthened the project’s cohesion and future readiness.
James
Contributed as a Software Developer
James has brought forward meaningful contributions to the Wheels through consistent code enhancements, test case development, and active engagement in issue resolution. He frequently submits detailed pull requests, helping to bolster the framework’s robustness and maintainability. Beyond code, James participates in discussion threads and reviews, offering thoughtful feedback which helps keep the project aligned with community needs. His steady involvement has strengthened both core modules and auxiliary features, making Wheels more reliable and polished for all users.
Andrew Bellenie
Contributed as a Software Developer and Maintainer
Andrew Bellenie has played a pivotal role in the Wheels ecosystem, as a long-standing core team member and active community contributor. He brings deep experience in CFML development and framework architecture. Andy has contributed code, design feedback, documentation, and mentorship to newcomers. He also helps triage issues, guide feature direction, and maintain the project’s stability. His dedication helps keep the framework evolving and its community engaged.
scahyono
Contributed as a Software Developer
scahyono has contributed thoughtful enhancements to the Wheels codebase, particularly in ensuring compatibility with Oracle setups. Notably, they worked on a module (or plugin) to allow ColdFusion on Wheels to correctly read table metadata across Oracle remote database links, which broadens database support and resilience. Their willingness to tackle specialized integration challenges strengthens the framework’s versatility and helps more users adopt Wheels in diverse environments.
MvdO79
Contributed as a Software Developer
MvdO79 has shown his support for the Wheels not only through code but also as a financial backer. He contributes monthly via Open Collective, helping sustain the framework’s ongoing development. Beyond funding, his presence in issue discussions demonstrates engagement with bug tracking and community feedback. His dual role-as supporter and participant-reinforces the open-source spirit behind Wheels.
Raul Riera
Contributed as a Software Developer
Raúl Riera has been an enthusiastic supporter and contributor to the Wheels community-beyond writing code, he’s helped through design, advocacy, and community engagement. He has designed swag such as T-shirts for Wheels events and promoted the framework through his dev shop, Hipervínculo. As a software entrepreneur (founder of Odonto.me) and developer, Raúl bridges technical and community roles, helping raise awareness of Wheels and adding a touch of creativity and outreach to the project’s ecosystem.
Michael Diederich
Contributed as a Software Developer
Michael Diederich has contributed key fixes and enhancements to the Wheels, particularly around framework usability and interface issues. Notably, he addressed documentation and UI elements-changes such as showing the current Git branch in the debug layout in version 2.5.0 reflect his involvement. In earlier releases, he also fixed bugs (for example with form and URL handling in the startFormTag() and array routing) that improved reliability across use cases. His contributions help refine both developer-facing tools and core correctness.
Rob Cameron
Contributed as a Software Developer
Rob Cameron had the original idea for CFWheels (and by extension, the foundation for Wheels), having built the framework with inspiration from Ruby on Rails in 2005. Though he eventually moved on from active core development to focus on other projects (such as Rails work), his early design and architectural direction still underpin much of the project's structure and philosophy.
Chris Peters
Contributed as a Software Developer
Chris Peters has been foundational in the development, documentation, and promotion of the Wheels framework since its early days. He authored many of the earliest releases, oversaw version 1.3.0 that introduced HTML5 enhancements, table less models, and thread-safe startup, and managed releases like 1.0.5 with dozens of bug fixes and stability updates. He also wrote technical blog posts about core features (flash messages, asset query strings, error handling) and established guidelines for contributing and documentation, helping to build a strong community around the framework.
David Paul Belanger
Contributed as a Software Developer
David Paul Belanger has been a core force behind the Wheels, contributing both technically and strategically across many versions. He has co-authored features and bug fixes (such as updates to sendFile() and usesLayout()) in the 2.x releases. Beyond code, David has helped lead the transition of the framework’s governance and been active in community outreach-having participated in CF-Alive podcasts and collaborated with Tom King and others on guiding the project’s future direction.
John Bampton
Contributed as a Software Developer and Documentation Writer
John Bampton made his mark as a contributor to the Wheels project beginning with version 2.4.0, where he helped fix broken links in documentation and correct spelling errors in the README and core templates. His attention to detail improved the documentation clarity and usability for future developers. Though he is noted as a “new contributor,” his work helped plug small but important gaps in the project’s written material, aiding the framework’s polish and accessibility.
Simon
Contributed as a Software Developer
Simon contributed to the Wheels framework by refining code and improving framework functionality. His work helped address issues and enhance stability, making the project more reliable and easier for developers to use. These contributions support the continued growth and effectiveness of the Wheels ecosystem.
Brian Ramsey
Contributed as a Software Developer and Quality Assurance Engineer
Brian Ramsey has been a long-time contributor and advocate within the Wheels community. His work spans both code contributions and knowledge sharing, with a focus on improving framework usability for everyday developers. Brian has participated in bug resolution, tested new releases, and provided feedback that shaped core improvements. Beyond code, he’s been active in community discussions, answering questions, and guiding newer users. His steady involvement has helped ensure Wheels remains both developer-friendly and reliable, reflecting his commitment to open-source collaboration and practical problem solving.
Danny Beard
Contributed as a Software Developer
Danny Beard has contributed to the Wheels framework through targeted code enhancements and thoughtful participation in issue discussions. His work has included fixing bugs, refining logic in core functions, and improving overall framework consistency. Danny’s involvement reflects an eye for detail and a practical approach to problem-solving, ensuring the framework remains dependable in real-world applications. Beyond code, his willingness to collaborate with other contributors has reinforced the community-driven nature of Wheels, helping maintain a strong and sustainable open-source project.
Reuben Brown
Contributed as a Software Developer
Reuben Brown has been a valuable contributor to the Wheels framework, offering code improvements and community input that strengthen the project’s overall quality. His work includes bug fixes and refinements that enhance stability and usability, ensuring developers can rely on Wheels in production environments. Reuben’s involvement extends beyond code, as he has taken part in discussions, reviewed issues, and provided practical feedback to guide development. His contributions reflect a thoughtful balance of technical skill and collaborative spirit, reinforcing the open-source ethos of the Wheels project.
Seb
Contributed as a Software Developer
Seb has provided important contributions to the Wheels that help improve framework robustness and usability. Through resolving issues, submitting pull requests, and polishing code, Seb has helped close gaps and make the system smoother for both new and experienced users. They’ve also participated in reviews, giving constructive feedback, which strengthens code quality and consistency across releases. Seb’s steady involvement supports the project’s open-source mission, making Wheels more reliable, maintainable, and welcoming for all contributors.
timbadolato
Contributed as a Software Developer
Timbadolato has contributed to the Wheels with a focus on improving functionality, fixing issues, and enhancing developer experience. His pull requests demonstrate a clear attention to detail, addressing edge cases and refining framework behavior to make it more predictable and reliable. By engaging in code reviews and community discussions, timbadolato has helped shape technical decisions and ensured smoother adoption for users. His contributions highlight a practical, solution-oriented approach that supports both the long-term stability and growth of the Wheels ecosystem.
Alex
Contributed as a Software Developer
Alex has played a supportive and constructive role in the Wheels, contributing code improvements and feedback that strengthen the framework’s overall reliability. His efforts include bug fixes, refinements to core features, and helpful participation in discussions that guide project direction. By addressing issues and proposing practical solutions, Alex has contributed to making Wheels easier to use and more stable for developers. His involvement reflects a collaborative spirit and reinforces the open-source values that keep the project moving forward.
Chris Geirman
Contributed as a Software Developer
Chris Geirman made contributions to the Wheels that helped refine parts of the codebase and improve developer experience. While his involvement was smaller in scope, his participation still added value to the framework and reflects the spirit of open-source collaboration.
Zac Spitzer
Contributed as a Software Developer
Zac Spitzer provided contributions to the Wheels that helped address specific issues and improve framework stability. Though his involvement was brief, his work added value to the codebase and demonstrated the importance of community participation in strengthening and maintaining open-source projects.
Nikolaj Frey
Contributed as a Software Developer
Nikolaj Frey has made contributions to the Wheels framework that supported improvements in the project’s codebase and functionality. While his involvement was limited in scope, his participation still added meaningful value, reinforcing the collaborative nature of the open-source community that drives Wheels forward.
Gralen
Contributed as a Software Developer
Gralen contributed improvements to the Wheels framework that enhanced code quality and supported overall stability. Their work helped refine the project and contributed to making the framework more reliable for developers using it in real-world applications.
Doug McCaughan
Contributed as a Software Developer
Doug McCaughan contributed to the Wheels framework by helping refine functionality and addressing issues that improved developer experience. His efforts supported the stability of the project and ensured smoother use of core features. Through his work, Doug added value to the framework’s ongoing development and its open-source community.
Coleman Sperando
Contributed as a Software Developer
Coleman Sperando contributed to the Wheels framework by making improvements that strengthened its functionality and reliability. His work addressed specific areas of the codebase, helping to refine features and ensure a smoother experience for developers. These contributions supported the project’s ongoing growth and the collaborative effort behind Wheels.
Charlie Arehart
Contributed as a Software Developer
Charlie Arehart has supported the Wheels framework through his deep expertise in ColdFusion and the broader CFML ecosystem. He has provided valuable feedback, shared knowledge with the community, and highlighted best practices that strengthen adoption and reliability. His involvement helps connect Wheels development with the wider ColdFusion community, ensuring the framework remains relevant and accessible to developers.
Charley Contreras
Contributed as a Software Developer
Charley Contreras contributed to the Wheels framework by helping refine parts of the codebase and supporting improvements that enhance usability. His work added value to the project’s overall stability and reflects the collaborative effort of developers working together to keep the framework evolving and reliable.
Brant Nielsen
Contributed as a Software Developer
Brant Nielsen contributed to the Wheels framework by improving functionality and addressing issues that supported better performance and reliability. His work helped refine the codebase and enhance the developer experience, reinforcing the project’s commitment to building a stable and effective open-source framework.
Ben Nadel
Contributed as a Software Developer
Ben Nadel is a veteran ColdFusion developer known for deep technical thought leadership and contributions to the community, including work around Wheels and related topics. He writes regularly about extending and customizing parts of Wheels (for example, customizing the router/proxy component behavior to suit specific workflow preferences). He also shares experiments and educational posts (e.g. integrating HTMX in ColdFusion apps) that help other developers understand modern patterns in CFML. While he may not always be contributing direct core framework commits, his influence shows up in how people use and adapt Wheels in real-world apps, and in sharing best practices, tutorials, and ideas that help shape how the framework is viewed and utilized.
Andrei B.
Contributed as a Software Developer
Andrei B. contributed to the Wheels framework by helping refine code and improve functionality in targeted areas of the project. His efforts supported greater stability and usability, making the framework more dependable for developers. These contributions reflect the collaborative spirit that drives the ongoing success of Wheels.
Adam Larsen
Contributed as a Software Developer
Adam Larsen contributed to the Wheels framework by improving functionality and addressing issues that enhanced the stability and reliability of the codebase. His work helped refine features and ensure a smoother experience for developers, supporting the ongoing growth and maintenance of the project.
Share Your Experience!
We'd love to hear about your experience! Would you take a moment to share a testimonial?