DevTools-X

DevTools-X is a lightweight, cross-platform desktop application that replaces a scattered collection of OS-specific tools with a single 10MB installer. It bundles 41 offline-first developer utilities — from a REST client to a regex tester to a bulk image compressor — all accessible without an internet connection and without the memory overhead of Electron.

Built with React and Mantine for the UI layer and Rust via Tauri for native system capabilities, DevTools-X delivers fast, secure utility modules that run as a native binary on Windows, macOS, and Linux. Performance-sensitive tasks like image compression and hashing are offloaded to Rust, while the frontend uses Monaco Editor (the VS Code engine) for a first-class editing experience across every text-based tool.

The app stores preferences and module ordering in a local SQLite database, allows full drag-and-drop customization of the sidebar, and ships a Spotlight-style command palette for instant keyboard-driven navigation. Modules like the REPL tap into the EMKC Piston API to execute code in dozens of languages directly from the app. All tools share a unified theme, shortcut system, and backup/restore mechanism, giving the experience coherence despite the breadth of functionality.

With 1,500+ GitHub stars and 38 releases spanning three major version lines, DevTools-X is a growing community project that accepts contributions across both the TypeScript frontend and Rust backend layers. The project explicitly targets developers who move between macOS, Windows, and Linux and are tired of maintaining separate toolboxes for each platform.

What You Get

• Monaco Editor Integration - Every text-based tool in DevTools-X uses the Monaco Editor engine (the same engine that powers VS Code), providing syntax highlighting, multi-cursor editing, and auto-completion across JSON, SQL, YAML, JavaScript, and more.
• Multi-tab REST Client - Send HTTP requests across multiple independent tabs with configurable method, URL, headers, query params, and request body; middle-click to close tabs and add new ones on the fly.
• Bulk Image Compressor with Rust SIMD - Compress and convert batches of images (PNG, JPEG, WebP) using native Rust image processing with configurable quality settings and live before/after preview via react-compare-slider.
• Programming REPL via Piston API - Write and execute code in dozens of supported languages (Python, Go, Rust, Node, etc.) directly in the app by connecting to the EMKC Piston API, with ANSI output stripping for clean terminal-style results.
• Snippet Manager with SQLite Storage - Save, tag, search, and retrieve code snippets stored in a local SQLite database, with pagination, tagging, and Monaco Editor for editing stored code.
• QR Code Generator and Reader - Generate QR codes from any text or URL with downloadable output, and read QR codes from image files using Rust-backed decoding.
• JWT Decoder - Paste any JWT token to instantly decode and inspect the header, payload, and signature; useful for debugging authentication flows without sending tokens to third-party services.
• Color Tools Suite - Includes a color converter/picker, color harmonies generator (complementary, analogous, triadic, split-complementary), and a color testing/accessibility checker for contrast ratios.
• Drag-and-Drop Sidebar Ordering - Reorder any of the 41 modules in the sidebar via drag-and-drop using @hello-pangea/dnd; order is persisted in a local JSON settings file.
• Spotlight-Style Command Palette - Press Mod+K or / to open a fuzzy-search overlay that jumps to any tool instantly from anywhere in the app.
• Text Compression Utilities - Compress and decompress strings using gzip, deflate, and zlib directly in-browser, useful for debugging compressed API payloads.
• Mock Data Generator - Generate realistic fake data (names, addresses, emails, credit cards, etc.) across multiple locales and output formats using deep Faker.js integration.

Common Use Cases

• Offline API debugging without Postman - A backend developer uses the multi-tab REST client and JSON formatter to test local endpoints on an air-gapped network, keeping sensitive auth tokens off the wire.
• Cross-platform image optimization - A designer compresses batches of PNG assets before committing them to a repo, using the Rust-backed bulk compressor to get smaller files without installing platform-specific tools.
• Inspecting production JWTs quickly - A DevOps engineer decodes JWTs from Kubernetes pod logs to verify audience, expiry, and claims without copying tokens into an online decoder.
• Learning a new language in isolation - A developer uses the REPL module to run Python, Ruby, or Rust snippets through the Piston API without setting up a local runtime environment.
• Building regex patterns interactively - A QA engineer uses the Regex Tester to design and validate complex patterns with match highlighting in real time before embedding them in test scripts.
• Generating boilerplate TypeScript types from JSON - A frontend developer pastes a JSON API response into the Quicktype tool and immediately gets TypeScript interfaces, Zod schemas, or Go structs.

Under The Hood

Architecture DevTools-X follows a feature-driven directory structure where each of the 41 utility modules lives in its own subdirectory under src/Features/, keeping cross-feature coupling low and making it straightforward to add new tools without touching existing ones. A shared AppContextProvider manages lightweight global state — pinned items and editor theme preferences — while per-feature state is entirely local. React Router maps URL paths to feature components, and lazy loading via @loadable/component defers nearly all modules until first navigation, keeping initial load time short. The resizable panel layout wraps the sidebar and content area, persisting the split ratio across sessions. The Rust layer in src-tauri/ registers a small set of Tauri commands for capabilities the JavaScript sandbox cannot provide natively: image compression, hash calculation, HTML minification, ping, QR decoding, and Base64 image encoding. This split — JavaScript for UI and orchestration, Rust for compute-intensive or system-privileged operations — is the defining architectural choice.

Tech Stack The frontend is React 18 with TypeScript, styled through Mantine 7 (a comprehensive component library providing theming, notifications, spotlight, and date pickers), and Monaco Editor via @monaco-editor/react for all code editing surfaces. Routing is handled by React Router 6.22. The desktop runtime is Tauri 2.x, which provides a sub-10MB native binary and exposes plugins for filesystem access, clipboard, SQL, dialog, auto-updater, and process management. The Rust backend uses the image crate for image processing and tauri::command macros for IPC. State persistence uses @tauri-apps/plugin-store for settings (backed by a JSON file) and @tauri-apps/plugin-sql for the snippet manager (backed by SQLite with migrations defined in Rust). The build pipeline uses Vite 5 with SWC for fast hot-module reloading, TypeScript for type checking, and cliff.toml with git-cliff for automated changelog generation.

Code Quality DevTools-X has no automated test suite — no unit tests, no integration tests, no Rust #[test] blocks were found in the codebase. This is acknowledged in the README under “NEED HELP WITH”. The codebase uses TypeScript throughout, but any types appear across a substantial portion of feature files, reducing the safety net type checking provides. ESLint and Prettier are configured and enforced via husky pre-commit hooks and lint-staged, ensuring consistent formatting. TODO and FIXME comments are spread across multiple files, including the Regex Tester (described as “kinda broken”) and the REPL’s runtime caching logic. Error handling in features largely relies on console.error and basic catch blocks rather than typed error handling. Despite these gaps, the code is consistently organized, imports use path aliases cleanly, and the feature isolation pattern makes the codebase navigable for contributors.

What Makes It Unique The combination of Tauri’s near-zero overhead runtime with a deliberately broad feature surface (41 modules versus the typical single-purpose utility) is what sets DevTools-X apart. Rather than excelling at one thing, it aims to be the single desktop app a developer needs to avoid installing ten others. The REPL module’s use of the EMKC Piston API for polyglot code execution — Python, Rust, Go, Node, and dozens more — without requiring local runtimes is a practically useful shortcut. The drag-and-drop sidebar with persistent custom ordering, collapsible icon mode, and Spotlight-style search creates a navigation layer that scales with the number of tools. The Quicktype integration for generating typed interfaces from JSON samples and the stateless (LessPass-based) password generator are features rarely found in native dev utility apps, reflecting a community that contributes domain-specific tools rather than just generic converters.

Self-Hosting

DevTools-X is released under the MIT License, one of the most permissive open-source licenses available. You can use it commercially, modify the source code, redistribute it, and incorporate it into proprietary workflows without any obligation to release your modifications. The only requirement is that the original copyright notice and license text are preserved in any distribution. There are no copyleft implications — self-hosting or embedding DevTools-X does not require you to open-source your own code.

Operationally, DevTools-X is a local desktop application, not a service you host on a server. Each user installs the prebuilt binary from the GitHub Releases page (or compiles from source using the Tauri toolchain). There is no backend infrastructure to maintain, no database to back up on your behalf, and no network dependency for the vast majority of tools. The only external call the app makes at runtime is to the EMKC Piston API for the REPL module and to GitHub for update checking — both optional behaviors. Deployment is as simple as distributing the installer file; the app stores all state in a local settings JSON and a SQLite database in the OS’s application data directory.

There is no paid tier, cloud offering, SaaS alternative, or enterprise edition of DevTools-X. What you see in the open-source repository is the complete product. This means you get no support SLAs, no managed update service, and no vendor-backed security patching — responsibility for keeping the app current rests entirely with your team. The tradeoff is total cost: the app is free, there is no lock-in, and teams with diverse OS environments (macOS, Windows, Linux) get identical tool availability without per-platform licensing concerns.