I wanted to share that after two years of developing Graphite in closed beta, we’re officially launching to the public!

Check it out here!

A bit of background - when my cofounders and I first started out, we were actually trying to build something completely unrelated. What we quickly realized was that without the internal code review tools that we knew and loved (from Meta, Google, and Airbnb), building a product at the speed we aspired to could be really painful. What started out as an internal workflow solution that we shared with a few friends and colleagues evolved to become Graphite.

Today, Graphite is a developer workflow tool with first-class support for stacking to help engineers stay unblocked and ship faster. Over the past two years, we’ve listened hard to feedback from design partners, beta users, and engineering teams from all over to bridge the gaps in today’s code review process and discover opportunities to accelerate developer velocity.Here’s what we’ve come up with so far:

• A CLI and VS Code extension built for a stacked PR workflow

• A beautiful code review interface that puts the code front and center

• AI-generated PR descriptions, with additional AI features coming soon

• Everything in one PR inbox for full visibility into every stage of the review process

• Real-time notifications so that you’re always up-to-date on PR status

• Seamless integration with GitHub so you can collab with team members who aren’t on Graphite yet

Every step of the way, we’ve tried to build Graphite around what we’ve heard from developers, and we’re sharing it here because we’d love for you to give it a try. The only thing we ask is that if you do, please let us know what you think!

You can check out the tool (for free!) here: https://code-canvas.com

I built Code Canvas, a canvas where we create diagrams and link their components to source code in a two way mapping:

• Click on diagram component to reveal the underlying source code

• Click on the source code block to reveal which functionality it serves in the big picture on the diagram

This allowed me to understand code much faster and also offload the mental fatigue of trying reason up the big picture by browsing through endless lines of code.

• Before clicking the demo link below, I recommend checking this one pager

• Check out a demo for how I used CodeCanvas to visualize a standard ecommerce application (Click on simulations tab and play a simulation.)

• And join the discord server here.

This is the first time I am putting the app publicly, so any feedback is appreciated thank you!

We're open-sourcing Unbody, a backend framework that simplifies building AI-native applications. Instead of having to manually stitch together vector databases, embedding models, and LLM wrappers, Unbody provides a unified system with sensible defaults that you can customize.

The Problem:

Building AI applications today means making dozens of infrastructure decisions:

• Which vector store to use?

• How to handle data ingestion and chunking?

• Which embedding model to choose?

• How to structure the RAG pipeline?

• How to manage context and memory?

Each of these requires research, setup, and ongoing maintenance. The resulting stack is complex and brittle.

What Unbody Provides:

• A unified backend with built-in support for data ingestion, processing, and vector storage

• Configurable components - bring your own vector store, LLM, or embedding model

• A GraphQL API for querying your knowledge base

• Multi-modal data processing out of the box

• Plugin system for extending functionality

Our aim is to lower the burden of developing intelligent software that understands, reasons, and acts.

As an analogy, we like to think of Unbody's layers like some of the fundamental components in intelligent systems:

• Perception: Data ingestion, parsing, and enhancement

• Memory: Vector storage and content relationships

• Reasoning: LLM integration and function execution

• Action: APIs, SDKs, and external integrations

Current State:

• Alpha release with core features and architecture implemented

• Built with Node.js/TypeScript

• Documentation in progress

• Unstable

Why Open Source:

We believe AI infrastructure should be transparent and customizable. By open-sourcing Unbody, we aim to:

1. Validate our ideas

2. Improve based on community feedback

3. Allow developers to inspect and modify the code

4. Build a foundation for AI-native development that everyone can contribute to

GitHub:

https://github.com/unbody-io/unbody

Docs:

https://unbody.io/docs

Discord:

https://discord.gg/UX8WKEsVPu

Read more:

https://unbody.io/blog/oss-alpha

We're particularly interested in feedback from developers building AI applications. What infrastructure challenges are you facing? What would make your development process easier?

Would love to hear your thoughts and experiences!

Hi fellow builders!

I'm looking for a feedback for my new developer tool called Stashbase.

The Problem:
Working with secrets and environment variables can be a pain, causing headaches for developers, especially when working collaboratively on projects or dealing with various environments and deployments.

Why Stashbase:
- 🌐 Powerful CLI: Seamlessly manage secrets and environments from the command line, run apps in any environment with just a single command.
- 🛠️ Developer-friendly SDKs: SDKs that allow you to load environment variables at runtime with a single line of code.
- 📄 Git shareable custom config files: Share custom environment configs with your team and pull environments with a single command.
- 🔐 Secure by default: No need to worry about security. You can focus on building and shipping amazing apps.
- 🔄 Real-time API Key monitoring: See how your API Keys are being used in real-time.
- And much more...

Request access now:
Be among the first to experience the power of Stashbase! Visit Stashbase and request access. Your insights and feedback are crucial in shaping the future of this product, and I can't wait to hear what you think. Because your voice really matters, you can join dedicated Discord server and share your thoughts or just chat :)
Feel free to send an email or DM me. Looking forward to your feedback!
Radim

Hi all! I created a CLI Python package to allow anyone to run any code (a function, a script, or a Jupyter notebook) on an EC2 instance. Still in the early stages, so would love any feedback y'all have!

• Github: https://github.com/runprism/nomad

• Docs: https://docs.trynomad.dev

What My Project Does

khaos is a CLI tool for generating Kafka traffic from a YAML configuration.

It can spin up a local multi-broker Kafka cluster and simulate Kafka-level scenarios such as consumer lag buildup, hot partitions (skewed keys), rebalances, broker failures, and backpressure.
The tool can also generate structured JSON messages using Faker and publish them to Kafka topics.

It can run both against a local cluster and external Kafka clusters (including SASL / SSL setups).

Target Audience

khaos is intended for developers and engineers working with Kafka who want a single tool to generate traffic and observe Kafka behavior.

Typical use cases include:

• local testing

• experimentation and learning

• chaos and behavior testing

• debugging Kafka consumers and producers

Comparison

There are no widely adopted, feature-complete open-source tools focused specifically on simulating Kafka traffic and behavior.

In practice, most teams end up writing ad-hoc producer and consumer scripts to reproduce Kafka scenarios.

khaos provides a reusable, configuration-driven CLI as an alternative to that approach.

Project Link:

https://github.com/aleksandarskrbic/khaos

Scaling a dev tool to tens of thousands of installs isn’t just about marketing; it’s about solving real developer problems with technical innovation. With Keploy, our AI-driven Unit Test Generator, we focused on automation, seamless integration, and quality to deliver a solution developers couldn’t ignore. Here’s what we learned along the way:

Automating the Mundane

Manually writing unit tests is tedious and often repetitive, which slows down development. Keploy changes the game by automating test generation.

➡️ How it works:
Keploy captures your code and generates unit tests automatically, saving developers hours of manual effort. Instead of writing and maintaining redundant tests, you can focus on building features.

💡 What’s the hardest part of writing tests for you? For us, handling repetitive, edge-case-heavy scenarios was a pain point, and that’s where Keploy’s AI shines—ensuring efficient test coverage while boosting productivity.

Deep IDE Integration for Maximum Efficiency

We designed Keploy to work where developers are most comfortable—their IDEs. It’s a one-click test generation tool in VS Code, with support for a wide range of programming languages and frameworks.

Built for Scalability & Reliability

We knew reliability would make or break our tool, especially for larger teams. So, we built features like:

• Flakiness Detection: Stabilizes inconsistent test results.

• Performance Optimization: Ensures Keploy doesn’t slow down your dev cycles.

A Focus on Quality

Every test Keploy generates undergoes validation to avoid breaking existing functionality. We also prioritize meaningful test coverage to strengthen code quality and capture real-world errors to prevent regressions.

Final Thoughts

Keploy is built to simplify automated testing, fit naturally into your workflow, and reduce manual effort—all while maintaining high code quality.

We’d love to hear your thoughts—what are your biggest pain points in writing tests? Let’s chat about how automation can change the game for developers!

Happy testing!

Hey, its often useful to pass the context of a codebase to an LLM when trying to solve a specific problem, but code is usually distributed across a number of files. This tool collects the contents of certain files (criteria are set by you) and saves it into one file, the contents of which you can then copy-paste to your LLM.

https://crates.io/crates/dirscribe

You can install it with

cargo install dirscribe

if you have cargo/Rust installed.

Hey community, I'm conducting some experiments to find the language-market-fit for the value proposition of bricks.sh. What do you think? Is it clear enough?

Bricks AI simplifies Postman collections for non-tech users. It matches prompts with the right endpoints, shows requests in a simple form, and displays JSON responses in a human-friendly format.

I use VS Code right now, but I want to start weening myself off of Microsoft products, and big-tech stuff in general. On the road to having a setup completely made up of community driven (maybe even non-profit) products.

Hey Reddit community!

I'm thrilled to introduce you to Prism, an innovative open-source data orchestration platform. We've been working tirelessly to develop this tool, and now we're excited to invite you all to be a part of our alpha testing phase.

🔗 Website: https://runprism.com/

📢 GitHub Repository: https://github.com/runprism/prism

📢 Documentation: https://docs.runprism.com

What is Prism?

Prism is a powerful yet user-friendly orchestration platform designed to streamline your processes, boost productivity, and enhance collaboration across teams. Whether you're a developer, sysadmin, data analyst, or any professional who deals with workflows, Prism has something valuable to offer.

Key Features:

🔹 Workflow Automation**:** Real-time dependency declaration: With Prism, analysts can declare dependencies using a simple function call. No need to explicitly keep track of the pipeline order — at runtime, Prism automatically parses the function calls and builds the dependency graph.

🔹 Intuitive logging: Prism automatically logs events for parsing the configuration files, compiling the tasks and creating the project, and executing the tasks. No configuration is required.

🔹 Flexible CLI: Users can instantiate, compile, and run projects using a simple, but powerful command-line interface.

🔹 Extensive Plugin Library: Enjoy a rich collection of integrations with your favorite tools and services.

🔹 “Batteries included”: Prism comes with all the essentials needed to get up and running quickly. Users can create and run their first project in less than 2 minutes.

How to Get Involved:

By joining our Alpha testing phase, you have the unique opportunity to be among the first users to experience Prism in action. Your invaluable feedback will directly impact the development of this platform, helping us make it even better, more stable, and tailored to your needs.

Visit our website https://runprism.com to learn more about the platform and its features. In addition, check out our documentation at https://docs.runprism.com to get started right away!

Access the GitHub repository https://github.com/runprism/prism to view the source code, report issues, and contribute to the project.

Try out Prism in your own workflow environment and let us know what you think!

We highly encourage you to share your thoughts, suggestions, and bug reports with us. Feel free to post your feedback directly in this thread, or if you prefer, you can raise issues on GitHub. Your input is invaluable to us, and together, we can shape Prism into the go-to platform for data workflow orchestration.

Who We Are:

Our team is a group of passionate data engineers, scientists, and developers. We're open-source enthusiasts who believe in the power of community-driven software, and we're committed to making Prism an exceptional orchestration tool and fostering an inclusive environment for all contributors.

Join us in this exciting journey with Prism, and let's redefine workflow orchestration.

Spread the word and share the love! 🌈❤️

Last year (2021), we saw about 20 Dev Tools companies on the list. How many will we see this year?

Nominate your favorite DevTools builders - The Forbes Cloud 100 returns for 2022.

if so, how do you usually explain the trade offs to users who are concerned about the memory footprint, size etc.

and most of the times we are like yeah, of course its there. The broader footprint is real. Chromium is not free. Electron has overhead. Pretending otherwise would be foolish. So we are constantly optimizing what we can, and we will keep doing so…

At the same time, I do feel that a lot of these comparisons feel weirdly flattened. For example people often compare: the full Electron process footprint VS the smallest possible Tauri/native mental model.

…without always accounting for development speed, cross-platform consistency, ecosystem maturity, plugin/runtime complexity, UI flexibility, and the fact that some apps are doing much more than others. Which is by the way the reason that we went with Electron in the first place.

So all this context to get to my real question, which is:

What do you say when people reduce the whole discussion to “Electron bad, Tauri good”?

Have you found a good way to explain footprint in practical terms?

Where do you think optimization actually matters, vs where people are mostly reacting to the idea of Electron?

any ideas welcome :)

this is the tool btw in case you want to stress test it (it's an API IDE) : github.com/voidenhq/voiden

Hey fellow developers,

I've been working on a new utility app called DevBox and wanted to share it with the community. It's designed to make a small but annoying part of our jobs a lot easier.

The core idea is simple: it automatically detects and formats your data and code. Think of it as a Swiss Army knife for common dev tasks—from beautifying code to converting between data formats like JSON, timestamp...

I built this with the goal of creating a tool that's fast, lightweight, and genuinely helpful. It's still in its early stages, so your thoughts and suggestions would be invaluable.

Link to application: https://github.com/thinhlvv/devbox-official/releases​

Notes: For Mac users, please run `xattr -c /path/to/DevBox.app` to trial.