Introduction
Engineering teams build more than just products. Along the way they create small tools, scripts, and utilities that solve everyday problems inside development environments. Many of these tools remain internal, even when they could help other developers facing the same issues.
At Westpoint, we occasionally release some of these internal tools as open source when they prove useful beyond the projects they were originally built for.
Dustoff is one of them.
At Westpoint, our primary work is building complex cloud systems and enterprise software for clients across multiple industries.
We are not an open source company in the traditional sense. Our focus is engineering delivery, solving real technical problems, and building production systems.
However, engineering work inevitably produces tools.
During real delivery projects we often build internal utilities that solve specific operational problems, simplifying developer workflows, automating repetitive tasks, or improving engineering environments.
Sometimes these utilities prove useful beyond the project they were originally created for.
When that happens, we believe it makes sense to share them.
Open Source as a Byproduct of Engineering Work
Many open source projects are built intentionally as products.
Ours usually start differently.
They begin as internal tools created during real engineering work. These tools are used inside development environments, infrastructure projects, CI pipelines, and production systems.
Only after a tool proves useful and stable do we consider releasing it publicly.
This approach ensures that what we publish is:
- practical
- battle tested
- based on real engineering problems
Instead of theoretical tools created only for distribution.
As Westpoint continues building internal engineering utilities, some of them will be released publicly when they can benefit other developers.
Dustoff
One of the tools we have released publicly is Dustoff, a CLI utility designed to help developers reclaim disk space from JavaScript and TypeScript build artifacts.
Modern JavaScript development environments generate large amounts of temporary build output such as:
- node_modules
- .next
- dist
- .cache
- coverage
- .turbo
Over time these directories accumulate across projects and can quietly consume large amounts of disk space.
Dustoff scans a filesystem, detects these artifacts, and allows developers to interactively browse and safely remove them.
Instead of manually searching through folders, Dustoff provides a terminal interface that makes it easy to identify large build artifacts and clean them up.
Built for Real Developer Workflows
Dustoff was designed to behave like a modern CLI tool that fits naturally into developer workflows.
Key capabilities include:
- scanning filesystems for common JS and TS build artifacts
- interactive browsing and selection
- sorting artifacts by size, path, or age
- search and filtering
- grouping artifacts by directory
- safe deletion with confirmation
- Vim style navigation alongside standard arrow keys
The tool can be run instantly without installation:
npx dustoff
Or installed globally:
npm install -g dustoff
The goal is simple. Remove friction from a common developer problem.
A Parallel Direction at Westpoint
Alongside our client engineering work, we are also establishing a parallel direction at Westpoint focused on releasing useful engineering utilities.
These tools usually emerge naturally from real delivery projects and internal workflows.
Areas where we expect tools to appear include:
- developer productivity tooling
- infrastructure automation utilities
- operational debugging helpers
- workflow and environment tooling
Rather than building open source software for its own sake, we publish tools when they have already proven useful internally.
Sharing the Thinking Behind the Tools
Alongside releasing tools themselves, we will also begin sharing the engineering insights behind them.
Future posts on the Westpoint Insights page will explore topics such as:
- the problems that led to certain tools being built
- design decisions behind the implementations
- lessons learned from using them in real environments
- engineering tradeoffs encountered during development
The goal is not only to release code, but also to share the thinking behind the solutions.
Try Dustoff
Dustoff can be run immediately using:
npx dustoff
You can also explore the project and contribute on GitHub:
https://github.com/westpoint-io/dustoff
Or check DUSTOFF website:
https://westpoint-io.github.io/dustoff-landing/
Built at Westpoint. Shared Openly.
Open source does not always have to be large frameworks or complex platforms.
Sometimes the most useful contributions are small tools that solve one problem well.
When we build something that can help other engineers, we will share it.
Dustoff is one of those tools.
More will follow.
