>VSCode Fork.
Already did. Can't wait to hear their super special very important reason why this can't exist as an extension.
"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."
(Btw if your comment already has replies, it is good to add "Edit:" or something if you're changing it in a way that will alter the context of replies.)
---
"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."
"Please respond to the strongest plausible interpretation of what someone says, not a weaker one that's easier to criticize. Assume good faith."
"Don't be curmudgeonly."
It'd be a security nightmare if it was more popular, but fortunately the community hovers around being big enough for serious work to be done but small enough that it's not worth writing malware for.
Over the years I have gotten better with vim, added phpactor and other tooling, but frankly i dont have time to futz and its not so polished. With VSCode I can just work. I don't love everything about it, but it works well enough with copilot i forgot the benefits of vim.
LSP experience with VSCode may be superior, but if I truly needed that, I would get an IDE and have proper intellisense. The LSP in Vim and Emacs is more than enough for my basic requirements, which are auto-imports, basic linting, and autocomplete to avoid misspellings. VSCode lacks Vim's agility and Emacs's powerful text tooling, and do far worse on integration.
But it's a different take, Brokk is built to let humans supervise AI more effectively rather than optimizing for humans reading and writing code by hand. So it's not a VS Code fork, it's not really an IDE in the traditional sense at all.
Intro video with demo here: https://www.youtube.com/watch?v=Pw92v-uN5xI
What I want is to be able to do is.
1. Create a branch called TaskForLLM_123 2. Add a file with text instructions called Instructions_TaskForLLM_123.txt 3. Have a GitHub action read the branch, perform the task and then submit a PR.
Did you mean to say a debugger? That one has an open alternative (NetCoreDbg) alongside a C# extension fork which uses it (it's also what VS Codium would install). It's also what you'd use via DAP with Neovim, Emacs, etc.
It's been a lot harder to build an IDE than an extension, but we think having full control over the IDE (whether that's VSCode or something else we build in the future) will be important in the long run, especially when the next iteration of tool-use LLMs comes out (having native control over Git, the UI/UX around switching between iterations, etc).
We're trying for thoughtful, respectful discussion of people's work on this site. Snarky, nasty oneliners destroy that.
We detached this subthread from https://news.ycombinator.com/item?id=43928512.
But I do stand by the point. We are seeing umpteen of these things launched every week now, all with the exact same goal in mind; monetizing a thin layer of abstraction between code repos and model providers, to lock enterprises in and sell out as quickly as possible. None of them are proposing anything new or unique above the half dozen open source extensions out there that have gained real community support and are pushing the capabilities forward. Anyone who actually uses agentic coding tools professionally knows that Windsurf is a joke compared to Cline, and that there is no good reason whatsoever for them to have forked. This just poisons the well further for folks who haven't used one yet.
I would still push back on this:
> all with the exact same goal in mind
It seems to me that you're assuming too much about other people's intentions, jumping beyond what you can possibly know. When people do that to reduce things to a cynical endstate before they even get off the ground, that's not good for either discussion or community. This is part of the reason why we have guidelines like these in https://news.ycombinator.com/newsguidelines.html:
"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."
"Please respond to the strongest plausible interpretation of what someone says, not a weaker one that's easier to criticize. Assume good faith."
"Don't be curmudgeonly. Thoughtful criticism is fine, but please don't be rigidly or generically negative."
Ycombinator backed too I guess Vibe coding is here to stay
Oh wow, I didn't even realize. Substantially less appealing of a project to me now.
1) Authority (whatever a prominent evangelist developer was peddling)
2) The book I was following as a guide
3) The tutorial I was following as a guide
4) The consensus of the crowd at the time
5) Whatever worked (SO, brute force, whatever library, whatever magic)
It took a long ass time before I got to throw all five of those things out (throw the map away). At the moment, #5 on that list is AI (whatever works). It's a Rite of Passage, and because so much of being a developer involves autodidacticism, this is a valley you must go through. Even so, it's pretty cool when you make it out of that valley (you can do whatever you want without any anxiety about is this the right path?). You are never fearful or lost in the valley(s) for the most part afterward.
Most people have not deployed enough critical code that was mostly written with AI. It's when that stuff breaks, and they have to debug it with AI, that's when they'll have to contend with the blood, sweat, and tears. That's when the person will swear that they'll never use AI again. The thing is, we can never not use AI ever again. So, this is the trial by fire where many will figure out the depth of the valley and emerge from it with all the lessons. I can only speculate, but I suspect the lessons will be something along the lines of "some things should use less AI than others".
I think it's a cool journey, best of luck to the AI-first crowd, you will learn lessons the rest of us are not brave enough to embark on. I already have a basket of lessons, so I travel differently through the valley (hint: My ship still has a helm).
Or, most software will become immutable. You'll just replace it.
You'll throw away the mess, and let a newer LLM build a better version in a couple of days. You ask the LLM to write down the specs for the newer version based on the old code.
If that is true, then the crowd that is not brave enough to do AI-first will just be left behind.
Not even, devoured might be more apt. If I'm manually moving through this valley and a flood is coming through, those who are sticking automatic propellers and navigation systems on their ship are going to be the ones that can surf the flood and come out of the valley. We don't know, this is literally the adventure. I'm personally on the side of a hybrid approach. It's fun as hell, best of luck to everyone.
It's in poor taste to bring up this example, but I'll mention it as softly as I can. There were some people that went down looking for the Titanic recently. It could have worked, you know what I mean? These are risks we all take.
Quoting the Admiral from Starcraft Broodwars cinematic (I'm a learned person):
"... You must go into this with both eyes open"
Context switching is not the bottleneck. I actually like to go away from the IDE/keyboard to think through problems in a different environment (so a voice version of chatgpt that I can talk to via my smartwatch while walking and see some answers either on my smartglasses or via sound would be ideal… I don’t really need more screen (monitor) time)
I do this all the time, and I am completely fine with it. Sure, I need to pay more attention, but I think it does more good than harm.
Now that I think about it, I might have only ever used agents for searching and answering questions, not for producing code. Perhaps I don't trust the AI to build a good enough structure, so while I'll use AI, it is one file at a time sort of interaction where I see every change it makes. I should probably try out one of these agent based models for a throw away project just to get more anecdotes to base my opinion on.
I actually flip things - I do the breakdown myself in a SPEC.md file and then have the agent work through it. Markdown checklists work great, and the agent can usually update/expand them as it goes.
At it's most basic, agentic mode is necessary for building the proper context. While I might know the solution at the high level, I need the agent to explore the code base to find things I reference and bring them into context before writing code.
Agentic mode is also super helpful for getting LLMs from "99%" correct code to "100%" correct code. I'll ask them to do something to verify their work. This is often when the agent realizes it hallucinated a method name or used a directionally correct, but wrong column name.
Senior engineers are not necessarily old but have the experience to delegate manageable tasks to peers including juniors and collaborate with stakeholders. They’re part of an organization by definition. They’re senior to their peers in terms of experience or knowledge, not age.
Agentic AIs slot into this pattern easily.
If you are a solo dev you may not find this valuable. If you are a senior then you probably do.
Most common these days is to make the paid product be a hosted version of the open source software, but there are other ways too. Experienced founders emphasize to new startups how important it is to get this right and to keep your open source community happy.
No one I've heard is treating open source like a bait and switch; quite the opposite. What is sought is a win-win where each component (open source and paid) does better because of the other.
I think there’s a general misconception out there that open sourcing will cannibalize your hosted product business if you make it too easy to run. But in practice, there’s not a lot of overlap between people who want to self-host and people who want cloud. Most people who want cloud still want it even if they can self-host with a single command.
https://techcrunch.com/2024/09/30/y-combinator-is-being-crit...
I'm working on an agnostic unified framework to make contexts transferrable between these tools.
This will permit zero friction, zero interruption transitions without any code modification.
Should have something to show by next week.
Hit me up if you're interested in working on this problem - I'm tired of cowboying my projects.
I'm still in vim with copilot and know I'm missing out. Anyway I'm also adding to the problem as I've got my own too (don't we all?!), at https://codeplusequalsai.com. Coded in vim 'cause I can't decide on an editor!
sudo chmod 755 path/to/Cursor-0.48.6.x86_64.AppImage
path/to/Cursor-0.48.6.x86_64.AppImage
The setuid sandbox is not running as root. Common causes:
* An unprivileged process using ptrace on it, like a debugger.
* A parent process set prctl(PR_SET_NO_NEW_PRIVS, ...)
Failed to move to new namespace: PID namespaces supported, Network namespace supported, but failed: errno = Operation not permitted
bin/appimage/Cursor-0.48.6-x86_64.AppImage --no-sandbox
The effort required to start Cursor is the reason I don't use it much. VS code is an actual, bona fide installed app with an icon that sits on my screen, I just click it to launch it. So much easier. Even if I have to write code manually.
Edit: asked gemini2.5 to make the script for you. Copy, chmod and run. (maybe check if I am not trolling you first).
#!/bin/bash
echo "Cursor AppImage Desktop Integration Script" echo "-----------------------------------------"
# --- Configuration --- # Default application name DEFAULT_APP_NAME="Cursor" # Directory to store AppImages APPIMAGE_DIR="$HOME/Applications" # Directory for .desktop files DESKTOP_ENTRY_DIR="$HOME/.local/share/applications" # Directory for icons (optional, if you want to copy the icon) # ICON_DIR="$HOME/.local/share/icons/hicolor/scalable/apps"
# --- Ensure target directories exist --- mkdir -p "$APPIMAGE_DIR" mkdir -p "$DESKTOP_ENTRY_DIR" # mkdir -p "$ICON_DIR" # Uncomment if you choose to copy icons to a standard path
# --- Get AppImage Path --- read -e -p "Enter the full path to your Cursor AppImage file: " APPIMAGE_PATH
if [ ! -f "$APPIMAGE_PATH" ]; then echo "Error: AppImage file not found at '$APPIMAGE_PATH'." exit 1 fi
# --- Get Application Name --- read -p "Enter the name for the application menu shortcut (default: $DEFAULT_APP_NAME): " APP_NAME APP_NAME=${APP_NAME:-$DEFAULT_APP_NAME}
# Sanitize APP_NAME for use in filenames (lowercase, no spaces) DESKTOP_FILE_BASENAME=$(echo "$APP_NAME" | tr '[:upper:]' '[:lower:]' | tr -s ' ' '_' | sed 's/[^a-z0-9_-]//g') if [ -z "$DESKTOP_FILE_BASENAME" ]; then DESKTOP_FILE_BASENAME="cursorapp" # fallback fi
# --- Define Target AppImage Path --- # Use the sanitized app name or the original AppImage name for the stored file # For simplicity, let's use a generic name like AppName.AppImage TARGET_APPIMAGE_NAME="${APP_NAME}.AppImage" TARGET_APPIMAGE_PATH="$APPIMAGE_DIR/$TARGET_APPIMAGE_NAME"
# --- Move and Prepare AppImage --- echo "Copying AppImage to '$TARGET_APPIMAGE_PATH'..." cp "$APPIMAGE_PATH" "$TARGET_APPIMAGE_PATH" if [ $? -ne 0 ]; then echo "Error: Failed to copy AppImage." exit 1 fi
echo "Making AppImage executable..." chmod +x "$TARGET_APPIMAGE_PATH" if [ $? -ne 0 ]; then echo "Error: Failed to make AppImage executable." # Consider cleanup or proceed if non-critical for .desktop creation itself fi
# --- Get Icon Path (Optional) --- ICON_ENTRY="Icon=$DESKTOP_FILE_BASENAME" # Default icon name, system might find it if themed read -e -p "Enter the full path to an icon file (e.g., .png, .svg) (optional, press Enter to skip): " ICON_PATH
if [ -f "$ICON_PATH" ]; then # Option 1: Use the direct path in the .desktop file ICON_ENTRY="Icon=$ICON_PATH" echo "Using icon from '$ICON_PATH'."
# Option 2 (More advanced, if you want to copy it to a standard location):
# ICON_FILENAME="${DESKTOP_FILE_BASENAME}.png" # Or get extension from ICON_PATH
# cp "$ICON_PATH" "$ICON_DIR/$ICON_FILENAME"
# if [ $? -eq 0 ]; then
# ICON_ENTRY="Icon=$DESKTOP_FILE_BASENAME" # Or $ICON_FILENAME without path if in theme path
# echo "Copied icon to '$ICON_DIR/$ICON_FILENAME'."
# else
# echo "Warning: Could not copy icon. Will use direct path if available or default."
# fi# --- Create .desktop File --- DESKTOP_FILE_PATH="$DESKTOP_ENTRY_DIR/${DESKTOP_FILE_BASENAME}.desktop" echo "Creating .desktop file at '$DESKTOP_FILE_PATH'..."
cat > "$DESKTOP_FILE_PATH" << EOF [Desktop Entry] Version=1.0 Name=$APP_NAME Comment=AI Powered Code Editor (AppImage) Exec="$TARGET_APPIMAGE_PATH" --no-sandbox %U $ICON_ENTRY Terminal=false Type=Application Categories=Development;IDE;TextEditor;Utility; StartupWMClass=Cursor # Often helps with icon association in docks/taskbars. May need adjustment. EOF
# Try to guess StartupWMClass if possible (more advanced, requires running the app and using xprop) # For Cursor, "Cursor" is a likely candidate. If window grouping issues arise, this might need to be # identified using a tool like `xprop WM_CLASS` on an open Cursor window.
if [ $? -ne 0 ]; then echo "Error: Failed to create .desktop file." exit 1 fi
# Make .desktop file readable (and executable for user, as some guides suggest) chmod u+rwx "$DESKTOP_FILE_PATH" # User read, write, execute chmod go+r "$DESKTOP_FILE_PATH" # Group and Other read
# --- Update Desktop Database --- echo "Updating application database..." update-desktop-database -q "$DESKTOP_ENTRY_DIR" # -q for quiet
echo "" echo "-----------------------------------------" echo "Success!" echo "'$APP_NAME' should now be available in your application menu." echo "If it doesn't appear immediately, you might need to log out and log back in or restart your desktop environment." echo "" echo "To launch, you can now search for '$APP_NAME'." echo "The AppImage is stored at: $TARGET_APPIMAGE_PATH" echo "The desktop shortcut file is: $DESKTOP_FILE_PATH" echo "" echo "If you encounter issues with the icon not showing up, ensure the path in '$ICON_ENTRY' is correct or place an icon named '${DESKTOP_FILE_BASENAME}.png' (or .svg) in ~/.local/share/icons/ or a system icon theme directory." echo "-----------------------------------------"
exit 0
The main reason I think there is such a proliferation is it's not clear what the best interface to coding agents will be. Is it in Slack and Linear? Is it on the CLI? Is it a web interface with a code editor? Is it VS Code or Zed?
Just like everyone has their favored IDE, in a few years time, I think everyone will have their favored interaction pattern for coding agents.
Product managers might like Devin because they don't need to setup an environment. Software engineers might still prefer Cursor because they want to edit the code and run tests on their own.
Cursor has a concept of a shadow workspace and I think we're going to see this across all coding agents. You kick off an async task in whatever IDE you use and it presents the results of the agent in an easy to review way a bit later.
As for Void, I think being open source is valuable on it's own. My understanding is Microsoft could enforce license restrictions at some point down the road to make Cursor difficult to use with certain extensions.
Another YC backed open source VS Code is Continue: https://www.continue.dev/
(Caveat: I am a YC founder building in this space: https://www.engines.dev/)
There are certainly a lot of alternatives that are plugins(!), but our differentiation right now is being a full open source IDE and having all the features you get out of the big players (quick edits, agent mode, autocomplete, checkpoints).
Surprisingly, all of the big IDEs today (Cursor/Windsurf/Copilot) send your messages through their backend whenever you send a message, and there is no open source full IDE alternative (besides Void). Your connection to providers is direct with Void, and it's a lot easier to spin up your own models/providers and host locally or use whatever provider you want.
We're planning on building Git branching for agents in the next iteration when LLMs are more independent, and controlling the full IDE experience for that will be really important. I worry plugins will struggle.
edit: ahh just saw that it is also a fork of VS Code, so it is indeed OSS Cursor
Claude Code (neither IDE nor extension) is rapidly gaining ground, it's biggest current limitation being cost, which is likely to get resolved sooner rather than later (Gemini Code anyone?). You're right about the right now, but with the pace at which things are moving, the trends are honestly more relevant than the status quo.
And Zed: https://zed.dev
Yesterday on the front page of HN:
I know some folks like using the terminal, but if you like Claude Code you should consider plugging your API key into Void and using Claude there! Same exact model and provider and price, but with a UI around the tool calls, checkpoints, etc.
That is until I started using Claude Code.
It’s not about the terminal. It’s just a better UX in general.
- The logo looks like it was inspired directly from the Cursor logo and modified slightly. I would suggest changing it.
- It might be wise to brand yourself as your own thing, not just an "open source Cursor". I tend to have the expectation that "open source [X]" projects are worse than "[X]". Probably unfair, I know.
Believe it or not, the logo similarity was actually unintentional, though I imagine there was subconscious bias at play (we created ours trying to illustrate "a slice of the Void").
Show HN: Void, an open-source Cursor/GitHub Copilot alternative - https://news.ycombinator.com/item?id=41563958 - Sept 2024 (154 comments)
Additionally, Zed is written in Rust and has robust hardware-accelerated rendering. This has a tangible feel that other editors do not. It feels just so smooth, unlike clunky heavyweight JetBrains products. And it feels solid and sturdy, unlike VS Code buffers, which feel like creaky webviews.
Next big sale is going to be something like "Chrome Fork + AI + integrated inter-app MCP". Brave is eh, Arc is being left to die on its own, and Firefox is... doing nothing.
One thing i'd really like to have is a manual order for folders or even files in the explorer view.
Tip: Write a SPEC.md file first. Ask the LLM to ask _you_ about what might be missing from the spec, and once you "agree" ask it to update the SPEC.md or create a TODO.md.
Then iterate on the code. Ask it to implement one of the features, hand-tune and ask it to check things against the SPEC.md and update both files as needed.
Works great for me, especially when refactoring--the SPEC.md grounds Claude enough for it not to go off-road. Gemini is a bit more random...
One thing I particularly don't like about LLMs is that their Python code feels like Java cosplay (full of pointless classes and methods), so my SPEC.md usually has a section on code style right at the start :)
Continue.dev also received investment from YC. Remember PearAI? Very charismatic founders that just forked Continue.dev and got a YC investment [1].
https://techcrunch.com/2024/12/20/after-causing-outrage-on-t...
Flaskbacks to that pretty good Voyager episode.
Is this feature on the roadmap?
It's compatible but has better integration and modularity, and doing so might insulate you a bit from your rather large competitor controlling your destiny.
Or is the exit to be bought by Microsoft? By OpenAI? And thus to more closely integrate?
If you're open-source but derivative, can they not simply steal your ideas? Or will your value depend on having a lasting hold on your customers?
I'm really happy there are full-fledged IDE alternatives, but I find the hub-and-spoke model where VSCode/MS is the only decider of integration patterns is a real problem. LSP has been a race to the bottom, feature-wise, though it really simplified IDE support for small languages.
We live in the age of dev tools
As a non-Cursor user who does AI programming, there is nothing there to make me want to try it out.
Feedback 2: I feel any new agentic AI tool for programming should have a comparison against Aider[1] which for me is the tool to benchmark against. Can you give a compelling reason to use this over Aider? Don't just say "VSCode" - I'm sure there are extensions for VSCode that work with Aider.
As an example of the questions I have:
- Does it have something like Aider's repomap (or better)?
- To what granularity can I limit the context?
We don't have a repomap or codebase summary - right now we're relying on .voidrules and Gather/Agent mode to look around to implement large edits, and we find that works decently well, although we're open to adding something like an auto-summary or Aider's repomap.
Regarding context - you can customize the context window and reserved amount of token space for each model. You can also use "@ to mention" to include entire files and folders, limited to the context window length.
(you can also customize the model's reasoning ability, think tags to parse, tool use format (gemini/openai/anthropic), FIM support, etc).
Back in 2023 one of the cursor devs mentioned [1] that they first convert the HTML to markdown then do n-gram deduplication to remove nav, headers, and footers. The state of the art for chunking has probably gotten a lot better though.
[1] https://forum.cursor.com/t/how-does-docs-crawling-work/264/3
If nearly everytime I use it to accomplish something it gets it 40-85% correct and I have to go in to fix the other 60-15%, what is the point? It's as slow as hand writing code then, if not slower, and my flow with Continue is simply better:
1. CTRL L block of code 2. Ask a question or give a task 3. I read what it says and then apply the change myself by CTRL C and then tweaking the one or two little things it inevitably misunderstood about my system and its requirements
Use gemini-2.5pro or sonnet3.5/3.7 or gpt-4.1
Be as specific and detailed in your prompts as you can. Include the right context.
I'm getting really tired of AI advocates telling me that AI is as good as the hype if I just pay more (say, fellow HNer, your paycheck doesn't come from those models, does it?), or use the "right" prompt. Give some examples.
If I have to write a prompt as long as Claude's system prompt in order to get reliable edits, I'm not sure I've saved any time at all.
At least you seem to be admitting that aider is useless with local models. That's certainly my experience.
In that case, a shitty, closed system is good actually because it's another thing your users will need to "give up" if they move to an alternative. By contrast, an open ide like void will hopefully make headway on an open interface between ides and the llm agents in such a way that it can be adapted by neovim people like me or anyone else for that matter
xwowsersx•3h ago
behnamoh•3h ago
kristopolous•3h ago
Also litellm
handfuloflight•2h ago
kristopolous•2h ago
If you're all in on Claude then yeah, just go direct. Going through a proxy of silly
NitpickLawyer•3h ago
manmal•1h ago
tough•3h ago
andrewpareles•2h ago