The local-first developer workspace.
80+ developer tools. API client. SQL. MongoDB. Redis.
Open source. Offline. Privacy-first.

Website · GitHub · Tools

Developers shouldn't need a browser full of random utility websites, a separate API client, a database GUI, a JWT debugger, a JSON formatter, a regex tester, and a dozen other applications just to get through a normal engineering day.

MyDevTools brings those workflows together.

It is a developer-focused toolkit built around one principle:

If a developer can do it locally, MyDevTools should make it possible locally.

From formatting JSON to debugging APIs, inspecting JWTs, working with SQL/MongoDB/Redis, generating developer artifacts, testing regular expressions, and handling security utilities — MyDevTools is designed to be the toolbox that stays with the developer.

🌐 mydevtools.tech

JSON YAML SQL GraphQL Markdown CSV Regex Diff

• JSON Formatter & Visualizer
• JSON Schema Generator
• JSON to Code
• SQL Formatter
• GraphQL Formatter
• YAML Formatter
• Markdown Preview
• JSON / CSV / Excel conversion
• Diff & JSON Diff
• JSONPath Playground
• Regex Tester

REST HTTP WebSocket DNS cURL

• API Client
• cURL to Code
• Webhook Tester
• WebSocket Tester
• HTTP Status Codes
• DNS Lookup
• URL Parser
• IP / Subnet Calculator
• User-Agent Parser
• MIME Type Lookup

AES JWT HMAC Hashing TOTP PEM

• JWT Decoder
• Hash Generator
• HMAC Generator
• Encryption Playground
• Password Manager
• Bcrypt Generator & Checker
• TOTP / 2FA Generator
• Certificate / PEM Decoder
• SSH / RSA Key Generator
• Secret / API Key Generator

SQL MongoDB Redis S3 Docker

• SQL Client
• MongoDB / NoSQL Client
• Redis Client
• Database Explorer
• S3 / object-storage workflows
• Docker Compose Generator

UUID Base64 Cron Mock Data Images CSS

• UUID / ULID Generator
• Base64 Encoder / Decoder
• Timestamp Converter
• Unit Converter
• Mock Data Generator
• Cron Builder
• .gitignore Generator
• Markdown Table Generator
• Image Compressor
• SVG Optimizer
• Favicon Generator
• Code Screenshot
• CSS Generators

And more.

MyDevTools is not intended to become another cloud-first developer SaaS.

We are building a local-first developer environment where privacy and speed are architectural properties.

If a transformation can happen on the user's machine, it should.

┌───────────────────────┐
│      Developer        │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│     MyDevTools        │
│                       │
│  Tools + Processing   │
│  + Local Workflows    │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│     Local Result      │
└───────────────────────┘

MyDevTools does not require an online storage or synchronization service for its core workflows.

The product is designed so developers can work with sensitive:

• source code
• API payloads
• credentials
• tokens
• certificates
• database queries
• configuration
• generated data

without having to upload that data to a MyDevTools cloud backend.

For security-sensitive utilities, processing locally is preferable to sending data to a remote server.

Examples include:

• hashing
• JWT inspection
• encryption/decryption utilities
• Base64 operations
• JSON transformation
• regex testing
• formatting
• secret generation
• certificate inspection

The project is built in the open so developers can inspect the implementation, contribute improvements, self-host where applicable, and understand how their developer tooling works.

MyDevTools uses a modern full-stack engineering ecosystem with a strong emphasis on TypeScript, Python, local processing, containerization, and pragmatic infrastructure.

                    MyDevTools
                        │
        ┌───────────────┼────────────────┐
        │               │                │
        ▼               ▼                ▼
     Frontend        Backend           Local Tools
        │               │                │
  Next.js/React     FastAPI/Python     TypeScript
  TypeScript        Pydantic            Local APIs
        │               │                │
        └───────────────┼────────────────┘
                        │
              ┌─────────┴─────────┐
              ▼                   ▼
           MongoDB              Redis
              │                   │
              └─────────┬─────────┘
                        ▼
                  Docker / AWS
                        │
                        ▼
                  GitHub Actions

The architecture intentionally separates developer-facing tools from backend services so that utilities that do not require a backend can remain local.

The most important architectural decision is knowing when not to use a server.

                 ┌─────────────────────┐
                 │    MyDevTools UI    │
                 └──────────┬──────────┘
                            │
             ┌──────────────┼──────────────┐
             │              │              │
             ▼              ▼              ▼
        Local Tools      API Tools      DB Tools
             │              │              │
             ▼              ▼              ▼
        Browser/OS       Network        Database
        Processing       Requests       Connection
             │
             ▼
       Local Developer
          Workflow

This distinction matters.

A JSON formatter doesn't need a backend.

A JWT decoder doesn't need a backend.

A regex tester doesn't need a backend.

A hash generator doesn't need a backend.

A developer should not have to upload sensitive data to a server simply because the tool they need happens to be hosted on the web.

Security-sensitive developer tooling deserves a different threat model.

We design around:

Don't transmit data that doesn't need to leave the machine.

Services and CI jobs should receive only the permissions they actually require.

The easiest workflow should also be a safe workflow.

Developers should be able to understand where their data goes and why.

Open source makes security review possible.

Third-party dependencies and build infrastructure are treated as part of the application's attack surface.

We treat MyDevTools as an engineering platform, not just a collection of utilities.

Our engineering workflow emphasizes:

Commit
  │
  ▼
Pull Request
  │
  ├── Lint
  ├── Type checks
  ├── Tests
  ├── Security checks
  ├── Build
  │
  ▼
Review
  │
  ▼
Deploy

Security and dependency checks are designed to fail closed where possible rather than silently producing false-clean results.

Services are containerized with Docker to keep development, testing, and deployment environments reproducible.

Cloud infrastructure is used for services that actually require infrastructure. Local developer utilities should not depend on the cloud merely to perform a local transformation.

Production services are designed around operational visibility, including:

• structured application logs
• service health checks
• failure visibility
• resource monitoring
• deployment verification

Our repositories are organized around clear responsibilities rather than one giant application.

Typical boundaries include:

mydevtools/
│
├── frontend/
│   ├── web application
│   ├── UI components
│   └── developer workflows
│
├── backend/
│   ├── APIs
│   ├── authentication
│   ├── application services
│   └── data access
│
├── tools/
│   ├── formatters
│   ├── generators
│   ├── security utilities
│   ├── API utilities
│   └── developer helpers
│
├── infrastructure/
│   ├── Docker
│   ├── deployment
│   └── CI/CD
│
└── docs/
    ├── architecture
    ├── development
    └── security

The exact repository boundaries may evolve as the platform grows.

We optimize for a short path from idea → implementation → useful tool.

A new utility should ideally be:

1. Easy to understand
2. Easy to test
3. Independent where possible
4. Reusable
5. Fast
6. Privacy-preserving
7. Consistent with the rest of the platform

We prefer composable primitives over tightly coupled features.

MyDevTools is released under AGPL-3.0.

We believe developer infrastructure should be inspectable and extensible.

Contributions are welcome across:

• 🧰 New developer tools
• ⚡ Performance
• 🎨 UI/UX
• 🔐 Security
• 🧪 Testing
• 🏗️ Architecture
• 🐳 Infrastructure
• 📚 Documentation
• ♿ Accessibility
• 🛠️ Developer experience

A good contribution doesn't just add code — it improves the developer experience.

Before opening a PR:

git clone <repository>
cd <repository>

# install dependencies
# run the development environment
# run tests
# verify lint/type checks

Please check the individual repository's README.md, contribution guidelines, and development scripts for the exact commands.

MyDevTools is evolving toward a broader developer operating workspace.

The long-term idea is not:

"Put 100 random tools on one website."

It is:

Build the local toolbox developers wish their operating system shipped with.

That means deeper workflows around:

Developer
    │
    ├── Code
    ├── APIs
    ├── Databases
    ├── Security
    ├── Infrastructure
    ├── Data
    └── Productivity
            │
            ▼
      MyDevTools
            │
            ▼
     One local workspace

The number of tools matters less than how much context switching we eliminate.

If MyDevTools saves you time:

⭐ Star the repositories
🐛 Report bugs
💡 Propose tools
🔐 Report security issues responsibly
🔧 Submit pull requests
📖 Improve documentation
📣 Share the project

Every contribution helps turn MyDevTools into a better open-source developer platform.

🌐 Website: https://mydevtools.tech

🧰 Developer Toolkit: https://mydevtools.tech/tools

📚 Documentation: https://mydevtools.tech/help

🔐 Security: https://mydevtools.tech/security

MyDevTools
Built for developers who want fewer tabs, faster workflows, and more control.

_{Open source · Local-first · Offline · Developer-first}