Launch HN: Haystack (YC S24) – Visualize and edit code on an infinite canvas (github.com)
We used to work as software engineers at big companies, and when the explosion in AI code-generation tools started we were really excited about them. They gave us a huge speed boost in our day-to-day work. But something was missing: writing code had become easier, but navigating codebases remained painful. We found that we were spending more time on the latter than the former!
Our vision of Haystack is an IDE that helps you navigate your codebase at speed. You should be able to type a vague description of the code you’re looking for (“Show me the code flow that triggers after we click the submit button”) and immediately see the right result. But we don’t think the traditional split-panel interface is the best fit for this type of rapid navigation. Inspired by the fluidity of design tools like Figma (Akshay used to work there!) and Miro, we realized that the canvas layout is a perfect way to represent and operate on code flows, and a great base for all the AI and collaborative tooling we want to build! This is how Haystack was born.
You might have seen our original Show HN (https://news.ycombinator.com/item?id=41068719) about two months ago. Since then, a ton of our users have told us that they’d love to contribute. We’ve made the decision to make the editor source-available so that folks can make contributions and so that they can examine the code to make sure they can trust it. Our repo is at https://github.com/haystackeditor/haystack-editor.
If you’re wondering why we’re going source-available rather than proper open-source: as a startup, we're going to eventually monetize and it’s too early for us to make the decision on whether going fully open-source is the right move. We want to own the distribution of Haystack until we can better understand the ramifications that open-sourcing would have, and whether it’s sustainable business-wise. We’d love to find a way to make proper open-source work, but it’s a one-way door, so we want to take our time to make sure we’re making an informed decision.
We would love to hear about what you think about having a canvas in your IDE and the role visualizations have to play in software development!
175 comments
[ 3.8 ms ] story [ 208 ms ] thread* when reading code, I found I jump back and forth the call stack quite often, a visualization of this could help with this navigation, especially with some properly designed shortcut keys.
* I mostly code on MacBook so screen real estate is precious. The canvas as main editor looks like waste a lot of screen space. But the canvas in a sidebar do not have this issue.
I don't think any of them will be successful, IMO. You want to be an extension because getting software approved is _hard_ at bigcos, it's much easier to trojan horse on an existing tool.
The reason I think there has been an explosion of VS Code forks (e.g. Supermaven, a very successful extension) is that being an extension in VS Code is limiting insofar as what you're able to change in terms of the UI and UX.
You are right about the difficulty of getting into big companies. However, we developed a standalone editor because it's easier to build on top of, and we eventually want to build a very portable browser-based editor that utilizes the canvas view for pull requests, arbitrary code, etc.
I am curious what features you like about Cursor the most? For me it's the CMD/CTRL+K -- I've had mixed experiences with the chat window and Composer.
This was at least the motivation for Positron, AFAIK.
In terms of manually resizing, we actually do try to tile in the viewport. May I know what's causing you to resize it so I can fix it?
I am happy to fix any bugs here. I am the only person I know who uses the Vim plugin in Haystack, so I haven't prioritized fixing the bugs I encounter.
If you get a demo of someone editing stuff super quickly using only keybinds I think it would look pretty cool.
Right now I don’t know if the value prop is strong enough for me to switch editors and remodel/relearn all my keybinds. This is like a 10-15% improvement not a 1.5x or 2x improvement.
An extension would probably help onboard users.
LSP + keyboard-driven interface is miles ahead in terms of efficiency and speed.
I respect the effort of breaking into less researched lands though. Congrats on the launch, I'm sure some will find this tool useful.
If you're a Vim user then this is an entirely different story haha.
But also agree that it's great that you're innovating in this space! Good luck!
The hard bit is making that to be "smart" and not annoying with things moving that you still need.
btw you should add a (small) gif or video in the github readme cuz that makes it really clear of what exactly its about.
Is it desirable enough to get them to switch IDEs?
Looks really intriguing, but Emacs is really hard to leave behind.
But I do believe this pattern applies to more things than just IDEs, and might even replace multi-workspace setup. Keep at it and hopefully you are successful and this pattern keeps evolving!
On the licensing side, though:
> We’ve made the decision to make the editor source-available so that folks can make contributions and so that they can examine the code to make sure they can trust it.
This is a very reasonable intent, and it absolutely makes sense to preserve your options to monetize, but Polyform Strict https://polyformproject.org/licenses/strict/1.0.0/ , which you link to from your readme, seems to be far stronger than this intent.
The way I read that license, I cannot "make changes" even if I do not distribute those changes, not even changing a line of code on a version I'm running on my own computer, whether I'm using it for a commercial project or not. So contributors, it seems, would be limited to raising issues but not PRs? And it's unclear what applies as commercial use - if I'm using Haystack on a commercial codebase, and I encounter a bug that triggers on that codebase, and want to use the Haystack source code to understand what's going on to further my commercial purpose, would that be an unlicensed use of the source code?
Now, make no mistake - this is in no ways worse than the prior status quo of Haystack being closed-source. And I think you as a company should focus on building, with the certainty and comfort that this license, if anything, does err on the side of being restrictive. But some users, given this license, will be uncomfortable referring to the repository at all. I'll be one of those, but will still be excited to experiment with Haystack as a binary distribution nonetheless!
(Not a lawyer, this is not legal advice!)
The intent is that you should be able to make PRs, examine the source code, but not distribute Haystack for commercial reasons.
I believe the license should allow you make PRs and examine code (even in commercial settings), but I'll take a more in-depth look.
Thank you for raising this to my attention!
https://availability.kemitchell.com/
I don’t know if I missed this in the video or if it’s not yet possible, but that’s a lot of manual work, so instead of connecting the nodes, give a simple bot to run in the repo folder to automate the visualization.
It’s super cool and I’m adding to my watch list.
If I were you, i’d target enterprise organizations or local municipalities IT groups who are going through or planning their digital transformations. They have a need for way-finding and sense making across legacy and new work.
If you play your cards right, Salesforce will come knocking in under a year. I see a lot of compatibility with their vision and product offerings.
This is a top user request though!
Ane I can then tell my coworker that the file needing change is in the upper right corners somewhere.
And git diffs being visual, can just zoom in on the changes here and there.
https://github.com/aappleby/wideboard
Btw I've always thought that this is even more powerful when the screen estate is more infinite than a 2D screen (like in a VR headset).
And, for whatever reason, the human exception handler for that problem is firmly linked to the barf() subroutine ;)
I think the barf routine is because when your brain senses your vestibular system not working it thinks "oops I must be poisoned" and tries to make you throw up.
Potential feature request - take the visualization beyond 2D. Really complex systems are usually an intricate graph (polite way of saying ball of yarn) and just visualizing in the 2D plane doesn't seem to cut it in my experience.
I would love to have something like concentric spheres of visualization - boundary services on the outer layer, core/domain services in the inner layer.
It's interesting that you mention a more 3D view. We were ideating on this, but it's really hard to get right in a way that the user can understand. This is definitely part of our vision for the future though!
EDIT: Deleted the bit about my speculation regarding Light Table since it's false.
There's definitely demand for this tool but it looks like it's hard to get it off the ground. Wishing you the best of luck!
I’m imagining a typical graph might end up looking a bit like this: https://upload.wikimedia.org/wikipedia/commons/thumb/8/81/07... in which case I’d want to have whatever cluster/file/method/object I’m focused on front and center with some visual cues like low-contrast and z-axis perspective that preserves edges to show the “far” clusters that interact with the focal point.
edit to add: as per usual, naming the clusters automatically might be hard.
I want this for C# and Python! Are their any technical challenges there? I would love to use this with Unity.
For Python, it should work just fine!
I'll experiment with this over the weekend and I might share it with my game dev friends!
https://learn.microsoft.com/en-us/dotnet/fundamentals/networ...
https://learn.microsoft.com/en-us/dotnet/fundamentals/networ...
It is, however, not dependent on VS Code and exists standalone, so it requires integration work if there's custom tooling at play. It is what most vendor SDKs that offer observability do.
There are CLI tools which consume the EventSource events and the EventPipe itself which can be used to access them in and out of process: https://learn.microsoft.com/en-us/dotnet/core/diagnostics/ev...
EventPipe/EventSource and DiagnosticPort are very powerful APIs however that cover much deeper instrumentation scenarios, so they are going to require writing a connector for the product that wants to integrate with them. There is already an implementation in shared code that is used by e.g. dotnet-trace which can be found here https://github.com/dotnet/diagnostics/tree/main/src/Microsof... but it can be a bit convoluted to read through.
https://www.youtube.com/watch?v=Ox5P7QyL774
More interesting search features were added after this video was made.
Tedious, yes, but confusing? Yikes!
My job as a coder is to resolve ambiguity favorably. Every day, I strive to leave the world less confusing than I found it. I would no more rely on an IDE to "take care" of confusion than I would outsource my firm's core competencies.
But the main conceit is cool, and I'm sure the dependency graph is helpful. I'm just picking nits with marketing copy. Can't wait to check it out! (Although my first instinct is to check for a canvas plugin for VScode).
Edit: I should say that I think this UI paradigm will fundamentally improve coder understanding by exploiting our visual cortex and "sixth sense" of proprioception, at least as far as I understand it via Supersizing the Mind (Andy Clark, 2008).
What was meant by this statement is really just taking care of plumbing and the visualization of how code relates to one another.
To give you a very basic/silly example of plumbing, if I add a parameter in a function used in 100s of places, doing the manual work to figure out what edits I need to make to those callers is pretty annoying and in most cases mechanical.
If you're lucky, you can do a grep + replace (or just use a default param), but in most cases I find it requires more manual intervention than that.
Edit: And "to figure out what edits I need to make" is done by any ol' compiler, no?
> Edit: And "to figure out what edits I need to make" is done by any ol' compiler, no?
Kinda? There are cases where you have to drill data down into the callstack (i.e. pass data from above). There are folks who have gone down this path before: https://www.jetbrains.com/help/resharper/Refactorings__Chang... but we intend to automate it even more and show it to the user in an organized way for them to handle large-scale "refactors".
1. Design the new architecture.
2. Gain a full understanding of the existing architecture and all of its trade-offs.
3. Design a way to convert the old architecture into the new architecture.
This happens surprisingly often and it's quite unavoidable. In the past, I tried to avoid redesigning by building things that could be expanded in every conceivable way, but I discovered that over-engineering actually makes it harder to redesign. YAGNI wins!
I've been thinking for a while that a canvas-type editor might help a lot in the process of redesigning. It should help by taking better advantage of spatial memory.
How do you plan on monetizing?
All right
> Collaborative
OH! YES!
> and generative AI features
Oh no.
Or is there a deeper experience/knowledge that gets unlocked coding in this paradigm?
For our users, Haystack has been helpful to understand how code works together, from simple React components to legacy C codebases that are a decade or older. I think the value prop shines when you're trying to understand how multiple pieces of code together, and this will become more useful as folks increasingly lean on AI tools to modify/create/delete multiple files.
It's a very active project and it's confusing to have two projects with the same name. Besides, I don't understand why you'd give a "2D digital whiteboard that automatically draws connections between code as you navigate and edit files" the name haystack.
The idea is that a codebase is much like a haystack and finding the relevant portions of it for a task or specific flow would be equivalent to finding needles.
Reposting this from another comment: For our users, Haystack has been helpful to understand how code works together, from simple React components to legacy C codebases that are a decade or older. I think the value prop shines when you're trying to understand how multiple pieces of code together, and this will become more useful as folks increasingly lean on AI tools to modify/create/delete multiple files.
Wow.
Thank you for sharing your work.
Please don't go down the GenAI bullshit bingo VC route.