I wonder how much of the poor traction Apache products gain is a result of the extremely low quality websites Apache projects tend to have.

None of the blog that is linked here, Netbeans github page, and the official NetBeans website have a single screenshot of what the application looks like. If you compare that to IntelliJ IDEA's website, it's filled with screenshots accompanying a writeup promoting the feature displayed in the screenshot.

NetBeans had been struggling to get perceived as more than an also-ran next to Eclipse and later IntelliJ long before it was handed over to Apache.

For Java development, I struggled with every IDE other than IntelliJ. It just seems to get more things right and can ingest and work with things like Gradle vs Maven, Spring Boot, decompiling 3rd party jars for debugging if you don't have the source, running a Windows UI driving a project that's inside WSL, etc. It's expensive, but worth it enough that I've paid for it when a company would not.

Yup, compare this to the awesome "New and noteworthy" posts that Eclipse publishes for each new version: https://www.eclipse.org/eclipse/news/4.25/jdt.php

This is also probably a reflection that NetBeans is a project on fast path to extinction.

The sad part is that before Apache takeover they had pretty decent website that put all the features and screenshots to the front:

https://web.archive.org/web/20160708090748/https://netbeans.... https://web.archive.org/web/20160708091639/https://netbeans....

Why did they waste time redoing it into something so useless is beyond me.

Because all of that was owned by Oracle and they didn't grant it to Apache.

There are countless companies running bizarre internal applications written using the NetBeans interface builder and I know for a fact they will never migrate away from it. It's certainly the also-ran of Java IDEs but 'extinction' is a little hyperbolic.

That "fast path" has been over 20 years long. That's an incredible amount of time for a software development tool.

I mean, netbeans was on the ascent at least as recent as 10 years ago, but then intellij stole their thunder, and eclipse held onto a core userbase more so than netbeans did.

Heh…I remember attending a Java dev conference in 2006 where attendees thought the mention of using NetBeans for professional development was a joke. Like the presenter prefaced a statement with, “if you use NetBeans…” and he wasn’t able to finish the sentence over the noise from the whole room erupting in laughter.

It has literally been a joke for at least 16 years.

Right before I came to the comments here I just failed in a search to find a summary of the most significant changes of this NetBeans version. This has happened to me on previous versions in the past as well - you have to either read the exhaustive list of changes on their github page, or get lucky and find some 3rd party blog that condenses it down for you. Why doesn't Apache write that blog themselves? Or have they and I just didn't stumble across it?

The NetBeans page does not even say what it is.

https://netbeans.apache.org/

"Development Environment", "Fast & Smart Editing", "Java, JavaScript, PHP, HTML5, CSS, and More"

yes it does?

All those call to actions are the bare minimum I'd expect of an IDE, nothing gives a unique selling point.

> It highlights source code syntactically and semantically, lets you easily refactor code, with a range of handy and powerful tools.

That's table stakes. Otherwise it's just notepad.

IntelliJ has me scroll down the page, but I then get a breakdown of what USPs IntelliJ thinks I a developer would be interested to know about, like it's refactoring and code completion, that it has specific integrations for frameworks. Testimonies, and new features are listed on that page. Not buried elsewhere.

VSCode, immediately shows that it's USP, it's extensions ecosystem, in the screenshot on the landing page and then covers some other minor USPs in brief segments.

Even Sublime Text, updated once every blue moon when Mars is in retrograde, understands that showing off USPs and the developer experience is key.

Now I used Netbeans for years, but only because I was exposed to it in the university computer labs. I've only had to go back to it to fix a JavaFX app we got landed with, and I can't say I was too impressed at how well it integrated with maven, having to ditch out and use the command line to get proper bundled builds to work.

The home page is almost identical since 2020 and it was slightly worse in 2018. Very impressive.

I used netbeans in high school when I was learning Java. The WYSIWYG swing editor is really nostalgic for me and helped me a lot, I’m glad to see it’s still active. Netbeans was actually an extremely good editor at the time, it was as good as IntelliJ and better than eclipse (imo).

Yes. I used it to create UIs using swing.

It's a mind-blowing and efficient IDE. A pity it doesn't support android development though otherwise Intellij would be out of business by now!

Is it that good, nowadays? Long, long time ago in university (okay not that long, around 2006), I first discovered NetBeans as superior Eclipse replacement, but about a year later IntelliJ as superior NetBeans replacement. And this was already for relatively simple stuff.

So superior that JetBrains would rather sell Clion licenses than support JNI development, meanwhile Netbeans has been doing it for at least a decade.

Agree completely that it's mind-blowing, it's my go-to tool when I do need an IDE (though I get most of my work done on emacs).

However, at my age, another thing that's mind-blowing is that this is now considered efficient. My first experiences with this was with (IIRC) was its predecessor, Forte for Java, and while I loved it, I remember it being a huge resource-hog. It's unbelievable to me how much computing power has improved to the point that something like NetBeans can be considered efficient (I don't discount their efforts in making it more efficient, but I think the fact we have more brute-force capacity these days certainly helps a lot).

Well, it's efficient if you compare it with the even newer (and even less efficient) generation of IDEs based on browser technology. Haven't used NetBeans in a while, but JetBrains are doing their very best to hide Java from you - their products come with their own (probably customized) OpenJDK so you don't have to have Java installed etc.

Scale down the speed of your processor and you quickly see what a resource hog jetbrains IDE are.

Emacs was once considered a resource hog. Eight Megs And Constantly Swapping...

Eventually Mallocs All Computer Storage

In the time of Forté For Java there were no SSDs.

Oh boy! Now, that's a name I haven't heard in a looong time :).

Around NetBeans 5 and 6 it was becoming pretty good to be a competitor to IntelliJ...

Around 10 years ago, when I was getting started with Android development, there was a plugin for that. I did try it first, but ended up going the official way with Eclipse.

IntelliJ is superior in every way. Better than NetBeans and Eclipse.

Except performance. Saying this as a daily intellij user. I still miss incremental compilation speeds for Java that were in the order of milliseconds rather than the 5-10 seconds (minimum, if you are lucky).

I love Kotlin but compiler speed is not one of its strengths. And with the round trip via Gradle, it just is guaranteed to take multiple seconds to process even a 1 character change in a unit test when you run one.

Eclipse used to be awesome for this with Java:

- error state of your project would update in real time while you were typing. Introduce a problem, the project goes red immidiately. Fix the problem, the red goes away immediately.

- Edit, run, type, edit run type, etc. without noticable delay. Intellij never had this.

The reason for this was a deeply integrated incremental compiler. It could even tolerate compilation errors and still allow you to run parts of your code. There are not many IDEs out there for any language that can do that. IBM did that 20 years ago with Eclipse and it's a feature I miss a lot.

you just beautifully summarised why i still use Eclipse today :-)

Once you get used to it, instant incremental compile >> everything else ...

Same here, much prefer Eclipse to IntelliJ. Super fast and provides instant feedback on everything you do with the incremental compilation. And the workspace is amazingly powerful as a concept.

I used to bash Eclipse (Netbeans fanboy :) ), then IntelliJ came into the picture without Javadoc completion out of the box (fixed nowdays), required explicit invocation of inspections, ten finger chords, no incremental compilation, no support for JNI development, indexing non stop,... and I re-learned how great Eclipse actually happens to be.

Incredible how often you hear the same about MSVC++6 or one of the Delphi's, up to 7.

There's a secret to kotlin compiler speed, and that's learning scala first ;)

And yes, the eclipse way of live embedded compilation to a classloader nested in the IDE process was awesome in more than one way. Probably an inheritance from its Smalltalk roots?

Some time ago I heard of a website dedicated to hating eclipse ide, but google can't find it. By any chance do you know what it is? Sorry if this comment sounds like gaslighting, I'm just curious.

Found it: https://bit.ly/3QK0Luz

Are you by any chance running windows?

Mac. It's not an OS thing. And no, it's not a virus scanner or something silly like that. I've seen the behavior replicated on lots of machines; including laptops belonging to other people that claimed it was my setup that was the problem. You set it up right, you get about 2-3 orders of magnitude difference in performance between Intellij and Eclipse. It's just that people get used to it and actually seem to think five seconds is pretty fast. Trust me, I've heard all the excuses over the years. When you've seen 50ms, 5 seconds is an eternity.

Not it isn't, specially for those of us that do JNI development.

JetBrains refuses to support it and points users to buy Clion instead.

Netbeans > Eclipse > IntelliJ when it comes to working on multiple projects. I still see colleagues who have a separate IntelliJ window open for each project they need to work with because IntelliJ makes it so damned convoluted.

> I still see colleagues who have a separate IntelliJ window open for each project they need to work with because IntelliJ makes it so damned convoluted.

I do this on purpose, because it's much easier than having all in a single window. IntelliJ always gives you the option to have them in a single window.

The single window option from IntelliJ is a hack of sorts, the last I checked they have some notion about importing a module vice a project. I'm not sure why on earth you would want separate windows though when, say, you're working on multiple Spring Boot projects and a couple of library jar projects that all interact with each other. Switching back and forth from window to window seems like self cutting.

Sadly for OSGi development there is no alternative to Eclipse.

Do we have any Netbeans users here ? It would be good to hear abit about the good/bad stuff (Thinking Java development mostly). How good/bad is it compared to IntelliJ ?

I spent years using NetBeans, then Eclipse, then IntelliJ IDEA and Android Studio, and now back to NetBeans. The features that made me return were having full C and C++ support (at the time, now less supported) and super-easy remote debugging. Those features let me write, build, and debug a Java application that interfaced with a Linux kernel device driver on an ARM Kobo Touch e-reader. Neither Eclipse nor IntelliJ IDEA could do that so easily.

And as mentioned in another comment, the direct support for the Apache Maven POM can make life easier, without the messy import required by the others.

With the new Flat Look-and-Feel with dark mode and the generally much better font rendering in Java, it finally looks great, too. There was a decade-long ugly period, though, which was one of the reasons I was desperately seeking alternatives.

I used NetBeans for C++ dev as well. But I had to stop several/many versions ago. They hard-coded a bunch of C++ version stuff, and it stopped getting updated. So when C++ was updated, beyond that, I stopped using NetBeans.

I've since progressed to VisualCode and CMake.

I use NetBeans, never used IntelliJ so can't provide a comparison.

Main reason that I use it is that Eclipse isn't built for the operating system that I use and is hard to port. I would like to see more modelling features in NetBeans, there are several free and commercial tools built on top of Eclipse, the documentation on XML stuff in NetBeans didn't match the implementation the last time I looked at writing a plugin myself.

I find it fascinating that there's so many Netbeans fans here on HN. Been doing software engineering professionally for 20 years now and ever since IntelliJ started becoming popular around 2005 almost every single dev I have ever worked with couldn't look at anything else. I've been through 7 companies and tens of projects and met a single Netbeans enthusiast.

These days Jetbrains is just a default option for C/C++, Rust (Clion), Python (Pycharm), Java (IntelliJ).

Wondering what's so specific about HN crowd that makes Netbeans so popular here.

You are assuming it is popular, and not that only a few vocal people are talking about it. Remember the HN community is large.

I use VSCode for most things, haven't tried the Jetbrains stuff much, besides in an interview where it worked "well enough".

Maybe eventually, I'll fork over and try the Jetbrains world. Maybe.

I think a lot of users jumped ship when it was donated to the apache foundation and no release happened for a very long time.

Correct, I'm one of them.

Basically because IntelliJ had support for Play Framework projects and was getting weird errors in Netbeans for some reason.

At the time Netbeans seemed ( and was ) dead on the water so I invested a bit o energy and frustration to learn the IntelliJ ins and outs of operating.

Still, I think and maybe it's an unpopular opinion, Netbeans auto-complete was top-notch and more "intelligent" than IntelliJ's, also much lighter IDE, IntelliJ has to thank the silicon Gods for all the cheap available RAM and processing power.

Netbeans team made one very good decision way back that IntelliJ still comes nowehere near to competing with: Integration with the underlying build system (Ant/Mvn/Gradle). IJ frequently gets itself into some weird state where it becomes uncoupled (unhinged?) from the Maven POM and has to be manually synchronised. Netbeans essentially does not have any independent notion of dependencies or build system, so there's never a sync question.

This also means that NB is infinitely better at handling/managing Maven sub-projects/modules, where IJ is pretty much always lost and blundering about in the wilderness.

All that said, I do believe that the Netbeans project has more-or-less lost the plot. They're spending so much time and energy trying to provide a language-server thing for VSCode that their own project is falling further and further behind the curve.

You’re spot-on about Netbeans’ Maven support. If you need to resolve a complex dependency conflict, figure out where a transitive dependency is coming from, etc.; it’s trivial in Netbeans and all but impossible in IntelliJ.

Try the (free, or premium) tabnine plugin. It uses a ML model to analyze your codebase for patterns and suggest better-and-better autocompletion over time as your project grows--it works really seamlessly with the IntelliJ autocomplete--so, it only adjusts the suggestion list when there isn't a straightforward suggestion from IntelliJ's already.

NetBeans’ auto-complete, in particular method call argument auto fill-in, is an important reason why it’s still my primary IDE for Java development.

It’s also slightly easier to (almost) fully keyboard-operate than IntelliJ, in my opinion.

Another thing I like is that Netbeans can open and work with Maven projects without having to “import” them.

"Cannot find Java 1.8 or higher".

It actually works with current Java, but you have to edit a configuration file first!

I have no idea why they find that acceptable and still ship it in this state.

It’s a purely open-source project now with not a lot of contributors and no company backing.

Again: it works perfectly with current Java (the ones everyone has by now), it is documented, they just chose a wrong default.

Don't tell me the sob story about the poor open source project. At some point the users' experience has to count, as well.

send a patch then, or alternatively listen to the poor open source projects sob story.

Well fix it then?

Indeed, it prefers "current" Java (17ish). I'm pretty sure you can't build NB on Java8 any more.

It's been a while since I've seen the name NetBeans! It was basically the Java IDE for a little while there, until Eclipse took over. Eclipse basically won because NetBeans used Swing for UI, and Swing was hot garbage back then -- the features were otherwise almost exactly the same.

Neat to see the project still hanging on, albeit pretty tenuously.

No, I think Eclipse won because multi IBM dinero for marketing (back in the day) while Netbeans was... just zese guys, you know. Yeh, later they got some Sun support, but initially it was just... open source?

I remember it as Eclipse taking over from Forte 4 Java, then NetBeans trying to regain share with various gimmicks, culminating with a fancy GUI layout tool that would have been excellent if it hadn't been exclusive to NetBeans.

Ehe I've yet another perception, I remember eclipse was what everyone used in my circles back then, mostly because it was the ide used for university courses.

Then forte died of acquisition, forte for Java bombed and NetBeans took over some interesting "4gen" features, so like given a table he would go and create the whole crud in swing on top. For a while it seemed to grow strongly but then eclipse opening up rcp fagocitated all thick client projects and NetBeans was left to dry.

It was almost 20yr ago so the time line is fuzzy, but this is how I recall it.

I could be mistaken as well, but this is the old Sun page for the IDE I'm referring to:

https://archive.ph/Qzllr

It looks like ffj predates the NetBeans acquisition, but it's hard to tell without a definitive reference. I found the original URL above via the C2 wiki.

so tried some googling and this old article conflates the two, so I'm now even more confused

https://www.developer.com/java/ejb/sun-forte-for-java-and-ne...

And now the leading Java IDE uses Swing anyway (IntelliJ).

I'm a long time NB user, I still use it as my daily driver.

The transition to Apache has been tough, but it's honestly amazing how well it does. The singular task of just "keeping up with Java" is load enough, much less adding on features. And, indeed, it doesn't have any formal sponsorship like it did under Oracle.

My singular nit with the project is that they rely a bit on external projects.

If there's one real power feature to NetBeans is that it's a first class Maven IDE. It works really well with maven.

Many of the "New Project" wizards are simply wrappers around maven archetypes.

But therein lies the rub.

Many of those archetypes are NOT "owned" or maintained by the NB project, they're 3rd party. You have NB maintained code designed to work with a specific maven archetype maintained by someone else.

I appreciate how the team doesn't necessarily want to be a domain expert in some specific aspect of the vast Java eco-system. But now you can't submit a pull request to the "team", you have to go to someone else who may, or may not, deem the request worthwhile.

So it causes a bit of friction of not having a single source of ownership to various features of the IDE.

Been out of touch with it, but, IIRC, NB's plugin story used to be pretty top notch (hot reload and all). Better than Eclipse and IntelliJ.

Geert W used to write a lot of good articles on doing cool and interesting things with NB, and user stories of how it was being used at different companies to build internal tools. Their GUI builder was pretty sweet too, IMO.

Glad to see it's still around!

NetBeans always struck me as the kind of IDE you would use to get things done in Java, as opposed to Eclipse which seemed to function as a portal into the vast and confusing world of Eclipse plugins.

But IntelliJ rules the (Java) world now, so they're both obsolete and redundant.

Back in the day I thought Netbeans rocked! Instead of the Lego-like assembly of plugins in Eclipse you got something that worked right out of the box (we're talking a 10-15 years ago and focused on Java/JEE/JSF).

I'm still sad they killed Ruby support. Netbeans was great for that!

I was similarly sad the NB C++ plugin was switched to a "language-server and good luck" approach. I actually do look forward to the day that language servers become on par with formal IDEs, but today is for sure not that day

Back when eclipse was still the king, Netbeans was actually quite a snappy and worthy alternative, especially as an official tool owned by Oracle.

tried doing some PHP work on it, it is very light weight & actually good. i tried moving around a few dockable windows and it almost looks and feels like intelliJ. it isn't as polished as intelliJ but it is slowly getting there.

on a side note, I have also noticed that a lot of programming language communities are likely taken over by intelliJ staff, your post gets shadow banned if you mention other IDEs.

Must everything be a conspiracy theory now?

If HN or some other forum is secretly infiltrated by Jetbrains staff, and they shadowban people mentioning other IDE's... then why does PyCharm seem like the #2 option (behind VS Code) in the Python community, and why does WebStorm seem even further behind in the Javascript and web dev world?

It just happens that IntelliJ is the market share leader for Java IDE's, followed by Eclipse (whose users trend older and corporate and less like to be active on forums at all). Developers are precious and toxic when it comes to their editor or IDE preferences, and often tend to downvote others.

It really is as simple and non-paranoid as that.

Was one of the best IDEs for Ruby dev waaay back in the day. I remember using it then. Jetbrains has long overtaken them though.

Yes! I did Ruby and JRuby in Netbeans for quite awhile. Deploying JRuby to GlassFish was just a nice right-click away.

Is there a way to make NetBeans look better?

IntelliJ looks so much better than NetBeans or Eclipse

You mean something like this? https://www.geeksforgeeks.org/netbeans-look-and-feel-plugin-...

There's also a FlatLaf plugin, actually very close to IntelliJ in looks.

There's been a lot of cosmetic improvements in NetBeans in the last few releases, including this latest one.

In particular, a while back the default look & feel was switched to FlatLAF ( https://www.formdev.com/flatlaf/ ), and before that again we did a lot of work to support HiDPI and Retina screens ( https://cwiki.apache.org/confluence/display/NETBEANS/HiDPI+%... ). In NetBeans 15 we did a series of tweaks to further improve the look of the UI (e.g. https://github.com/apache/netbeans/pull/4286 ).

I guess it comes down to personal taste, but the Jetbrains IDEs don't look great either. It's pretty far down my list of priorities and I'm a happy customer regardless, but they're all kinda ugly, very Java fat client-ish.

It's not even the non-native look and feel (what even is a native GUI these days?), VSCode somehow looks better.

ahh netbeans.... the memory black hole :) Im sure things have improved since then ?

> Im sure things have improved since then ?

Yep—Electron came along and made Java GUI programs seem trim and snappy. :-)