avallach
avallach on Hacker News
Fair point: perhaps the true advantage of long established enterprises and OSS orgs is not the process, which can be considered private implementation detail, but the public track record. Either way, startups don't have that.
I wonder if the flood of vibecoding startups may end up helping long established enterprises and OSS through eroding consumer trust towards new software, and highlighting the value of the industrial software development process. Bills of materials, 4-eyes code reviews, release gates, QA testers, planning involving domain experts, external audits etc. Any time I see a new large piece of software nowadays that seems to have popped out of nowhere and has generic sounding docs and testimonials with em dashes I tend to wonder if it was generated with a one shot prompt and may include vulnerabilities, malicious code, or business domain hallucinations.
It's a bit like with books: 10+ years ago I could have trusted a book from a new author I never heard about just because the large effort of getting published was hinting that the author is likely qualified. Now, hell no.
When the barrier to publish drops to zero, the barrier to gain trust skyrockets.
Also try Lapce! In my experience somehow starts noticably faster even than Zed. Also implemented in Rust but different GUI approach. Both support LSPs.
Correction: Rust is more than just Tauri glue code (
https://github.com/l0ng-ai/openidea/issues/568#issuecomment-...). But considering that in an IDE the two performance critical parts are code processing (LSP) and frontend, I wonder how much benefit can you really get by making everything except of them in Rust.
Overall I actually agree that VSCode has proven that making responsive web based frontends is absolutely viable for the IDE, if you accept startup latency, size and memory use of CEF / Electron. And on Windows and macOS, system WebView may be sufficiently compatible (not on Linux anytime soon!), and they significantly amortize all of those downsides.
Calling it "OpenIDEA" is a bit misleading. IntellijIDEA is free and open source (Apache 2.0) since 2009. Paid subscription basically gives you extra plugins. And as others pointed out, saying that it was rebuilt in Rust is at least as much misleading: the code processing is still standalone LSP processes, frontend is WebView with typescript, only Tauri glue code is Rust. And that in turn makes me extremely skeptical about claimed memory usage! Consider that you must compare idea.exe against combo of WebView (on windows: chromium edge) + LSP (for Java, likely Eclipse LSP, at least that's what VSCode traditionally uses for Java). Is it realistic to fit that in claimed 169 MB?
My experience: intuitive thinking it's a shortcut, but it's less reliable when it comes to complex problems, especially involving multiple concepts that have to be reasoned about with non trivial relationships or rules. In a way I see a spectrum of approaches that range from fast to reliable:
1. Intuitive thinking
2. Language based internal monologue
3. Written scratchpad
4. Explaining the problem to another person until they understand it (rubber ducking)
Like the response from the UltraSane: my thinking is and always was 100% made of internal language-based chain of thought ("imaginary talking to myself"), with some amount of introspection / meta reasoning when problem is particularly hard. This article indeed reads to me a bit like someone proposing a physical storage medium inspired by those pictures of little squares traditionally used as "save" icon, without realizing that this digital representation was in the first place based on an existing real world thing.
Anyway, a surprising related observation is that rubber ducking by describing the problem to quiet listener still often helps me, which suggests that internal chain of thought makes intuitive shortcuts that sometimes are counter productive, while talking to another person creates subconscious pressure to make the thoughts fully complete.
Possible env level fix: compile statically against musl libc and run under gvisor with otherwise empty filesystem.
From the same author: C# browser ide inspired by the modern visual studio
https://github.com/wieslawsoltes/SharpForgeHe has 500+ open source repositories including very advanced stuff like GPU powered gui framework and game engine components ( https://wieslawsoltes.github.io/Home ). It's very impressive and almost hard to believe that a single person could make all of this, even with help of modern ai agents.
This looks very cool! All the demo slots are taken at the moment. I'm curious: is the frontend just a dumb display server, or do you run there subset of GUI code responsible for latency sensitive feedback loops (typing, scrolling, dragging, maybe expanding menus etc)? E.g. is it vulnerable to network latency the same way as remote desktop solutions are?
Watermelon pieces are made mostly of water, but are solid as a whole, not liquid. You can't pour them. And if you actually blend them into a liquid, then you get watermelon juice or soup. (Soup vs beverage is a distinction based on the mode of serving, in a glass vs bowl+spoon)
Salads are dishes without a fixed structure. You can randomly rearrange the ingredients without changing it into another dish.
For example, a pizza is salad on top of dough, a burger is salad between buns, and a burrito is salad wrapped in a tortilla. But as a whole, pizzas, burgers, and burritos each have a strict, defined structure, so they aren't salads, they just contain a salad component.
Additionally, anything made mostly of liquid by volume is a soup or beverage, not a salad.
Do you have any limits on number of concurrent users and requests per account? Would a company with 2000 users get the same unlimited and unthrottled per user experience as company with 20 users?
I see no mention of those in the website (which actually emphasizes "no limits"), but this sounds unrealistic as it's plain obvious that there's a threshold of a team size which would make it economically unviable for you.
I worry it's like one of those unlimited data plans which upfront only states that they block malicious abuse but then runs out after watching two episodes on Netflix. It would be much more honest to admit upfront that there is a limit of some kind, and realistically there must be or you go bankrupt.
Another notable example: JetBrains Noria (
https://blog.jetbrains.com/fleet/2023/02/fleet-below-deck-pa... ).
As the authors highlight: "Noria is not a UI framework at its core. Instead, it’s a platform for incremental computations.". But currently they happen to use it to optimize gui rendering in JetBrains Air IDE.
Doesn't this mean we just need to make the webgl fingerprint resistance implementation smarter? Instead of explicitly rejecting webgl access or responding with dummy data, respond with data that is random within space of N common and reproducible patterns. E.g. emulate webgl implementation of some low spec but actually popular devices.
The whistleblower claim against them that I've seen:
> "Delve allegedly took an open source tool and passed it off as its own work without proper license attribution. The Delve folks said they built it themselves, the whistleblower contends. DeepDelver then presented alleged evidence that this tool was actually a fork — a modified copy — of SimStudio, changed just enough to be passed off as Delve’s own. If that proves true, it would be a violation of the Apache software license, which requires the original developer be credited."
https://techcrunch.com/2026/04/01/the-reputation-of-troubled...
Their defense in this article:
> "falsely claims we “stole” from another YC company when in reality we built on an Apache 2.0 open-source repository"
I'm really confused. Unlikely that they misunderstood the accusation. This looks a bit like admitting to half of the accusation, while completely misrepresenting what the accusation was, so that they could say that the whistleblower is a liar.
Isn't this actually improving safety by openly admitting how things always were in practice?
Any e2e encryption provided by the same entity who fully controls both the blackbox clients, and the server in between, is just a security theatre that they can selectively bypass anytime with very little risk of detection. Not really much better than simple client to server encryption.
Truly safe e2e requires open source client provided by a trusted entity who is as much as possible independent from the one who provides the untrusted transport layer. Eg how pgp email works.
If I wanted to make ad blocking hard, I'd first keep serving an easily blockable ad system while getting everyone used to extension API which only can block such simple systems. Only once it is fully adopted, I could switch to hard to block system.
Doing that in the opposite order would obviously harm adoption of my crippled extension API and push users to competing browsers which kept supporting the advanced API.
> how do we get large text to scale at a lower rate than body text
Express the header text size with CSS calc function with a sum of em (relative) and px (absolute) values. Depending on their ratio, element will be more or less scalable. 100% em -> scales like body text, 100% px -> no scaling.
Maybe I'm misunderstanding, but after reading it sounds to me not like "io_uring is faster than mmap" but "raid0 with 8 SSDs has more throughput than 3 channel DRAM".
It's even weirder than that: mention of the shell GUI is just the intro, later they proceed with implementing a facsimile of the Windows NT kernel in... TypeScript. Even for purely self-educational purposes, this pairing seems to be very counterproductive.
I agree that the title is misleading and should be changed. I also expected LG webOS.
@viraptor above mentions that they actually do try first with an explicit perplexity-agent:
https://news.ycombinator.com/item?id=44797682 . So there's no ambiguity. The worst they could accuse Cloudflare, is that they don't give website owners an easy way to only block scrapers while allowing user-driven agents (do they?).
I can totally see your point. It's a bit like that fight of news agencies against the free snippets and aggregations on 3rd party websites. The Internet is supposed to be open after all.
But it also feels like essentially "pirating" the webpages while erasing their brand. Maybe it's even a tolerable transitive situation, but you can't even argue it's beneficial in the same way as game piracy could be according to some. In the long term, we need an incentive for the content creators to willingly allow such processing. Otherwise, a lot of high quality content will eventually become members-only with DRM-like anti agent protections.
The incentive doesn't have to be monetary. I could for example imagine some website owners allow AI agents that commit to upfront verbatim repeating some sort of mandatory headers/messages/acknowledgements from the content authors, before copying or summarizing, and are known to stick to this commitment.
You can also bypass the problem already now by accessing and copying the content manually, and then putting it in the context of a tool like NotebookLM. Nobody's hurt, because you have actually seen the source by yourself, and that's all the website owners can reasonably demand.
TL;DR: why even post quality content in open if the audience won't see your ads, your donation button, or even your name. What do you think?
And then once they see that the website operator blocked the perplexity-user, apparently instead of respecting that, they not only ignore robots.txt, but actively try to bypass the security measures established with the explicit purpose of limiting their access. If this was about bypassing DRM rather than AI-WAF, it would be plainly illegal.
To me this invalidates their whole claim that Cloudflare fails to tell the difference between scraper and user-driven agent. Instead, distinguishing them is trivial, and the block is intentional.
Cloudflare did explain a proper solution: "Separate bots for separate activities". E.g. here: one bot for scraping/indexing, and one for non-persistent user-driven retrieval.
Website owners have a right to block both if they wish. Isn't it obvious that bypassing a bot block is a violation of the owners right to decide whom to admit?
Perplexity's almost seems to believe that "robots.txt was only made for scraping bots, so if our bot is not scraping, it's fair for us to ignore it and bypass the enforcement". And their core business is a bot, so they really should have known better.
The filename is 'poland.gif', I wonder what's the message there.
The post title is misleading. The algorithm did not leak, only the documentation listing all the signals that can possibly be used as inputs for that algorithm. It doesn't reveal which ones are actually used and how.