Blog

We are a team of passionate technologists dedicated to helping software businesses team up because business is better together

About Us

Generate ergonomic rust wasm-bindgen bindings for typescript definitions

Introducing... ts-bindgen!

At Ratchet Designs, we are experienced, opinionated computer scientists building composable abstractions that just work. Ratchet up your software team's productivity with our meticulously-crafted tools and components.

IS_RD

Subscribe

Simple tools for complex software

[Plugins.dev](https://plugins.dev) creates an app store for your app or site in minutes. Turn your app into a platform and create an ecosystem of 3rd-party plugins to drive unbounded value for your users.

* Earn money as users purchase plugins
* As users invest in creating content on your platform, empower them to extend your functionality to support their needs, positioning your brand front and center and keeping all users within your app
* As you sell to enterprise clients, allow them to invest in deeply integrating your app into their workflow or their workflow into your app.

Plugins.dev

*   [ts-bindgen](https://ts-bindgen.ratchetdesigns.com) generates ergonomic rust wasm-bindgen bindings for typescript definitions. Check out the [repo](https://github.com/ratchetdesigns/ts-bindgen) for a guide on using it in your own project or try [generating some bindings in your browser](https://ts-bindgen.ratchetdesigns.com) now.
*   [enum_to_enum](https://github.com/ratchetdesigns/enum_to_enum) is a rust [library](https://crates.io/crates/enum_to_enum) that makes it easy to build possibly effectful transformations between different enum types. Many useful programs can be written quite simply and directly as pipelines of such transformations. Check out [the docs](https://docs.rs/enum_to_enum).


Open Source Libraries

All of our tools are designed thoughtfully as composable elements that can seamlessly integrate into any stack.

Our tools

We will make important product announcements and share our latest thoughts about how to build composable systems at scale.

Subscribe to our thoughtful newsletter

Our industry has created abundance in the world and we have genuinely improved the lot of humanity but we are reaching the limits of what we can accomplish with the old ways.

As computer scientists, engineers, developers, or whatever you want to call us, we deal in mindstuff, an infinitely-maleable sea of abstraction. Our medium permits us to conjure forth from it any conceivable entities with any conceivable properties. Ask a structural engineer if they imagine their job would be easier, their product improved, and their timelines shorter if they could alter the laws of physics to their liking just in the vicinity of the bridge they're building. Or ask a wood-and-nails architect if they would want a roof that automatically expanded to cover last-minute changes to a 95% complete building.

We work in the ethereal realm, we have the all of the benefits of a complete absence of physically-imposed constraints that other professions can only dream of. And yet, we lament late-breaking changes more than any of them. How many times have we said that we can't accomodate some critical feature on any market-relevant timescale due to some assumptions baked deep and scattered wide throughout our system?

*We'd like to suggest a path out of this morass.*

* Codifying and leveraging universal laws of abstract systems. By abstracting over system details, we can solve universal problems across systems.
* Building simple ([in the Rich Hickey sense](https://www.infoq.com/presentations/Simple-Made-Easy/)) subsystems. A component that solves one problem and permits composition can be largely immutable. System structure ought to change quickly. We can enable that with single-purpose, context-free components.
* Orienting around long-term actionable knowledge accumulation at multiple levels of team organization. There is nothing sadder than lost knowledge. If you have to set up knowledge transfer sessions when a teammate quits, something is wrong.

**Ratchet Designs is committed to building simple tools and systems to allow our industry to take fewer steps back and realize the true potential of dealing in our most maleable of mediums.**

## Our goals
* Enable single-purpose companies and composable products. It simply should not require thousands of engineers to deliver and maintain an important product. Big tech is an anti-pattern. By creating generic systems, we can drive down the [asset specificity](https://en.wikipedia.org/wiki/Asset_specificity) of investment in large software systems and create economic incentives that favor small businesses engaging in ad hoc, a la carte partnerships to deliver user value.
* Create an ecosystem of composable pieces of single-purpose infrastructure with well-defined interfaces, capable of being dropped into any customer environment.
* Push our industry to reconsider base assumptions underlying our approach to large-scale system design. Not only can we do better, but the potential benefit to humanity we're leaving on the table necessitates that we **must** do better.

Our philosophy

Latest Posts

Home

Thank you for subscribing!  

We will share important updates and our latest thinking about this crazy world of software systems.

We want to hear from you - reply or shoot us a message at [adam@ratchetdesigns.com](mailto:adam@ratchetdesigns.com).