49
\$\begingroup\$

I'm not that big of a fan of the official Arduino IDE (in terms of visuals), so I've started looking for nicer alternatives. However, most of the projects I've found are in alpha/beta and are generally incomplete.

I'm 100% new to circuit board programming and I've never used an Arduino before, but from what I gather the Arduino IDE is just a wrapper for an avr library which does the actual writing to the board. Are other "arduino-like device" IDEs a possible option?

Again, I'm very new to this so user-friendly-ness would be nice.

\$\endgroup\$

closed as off-topic by duskwuff, PeterJ, DoxyLover, Marcus Müller, JonRB Oct 22 '17 at 14:51

This question appears to be off-topic. The users who voted to close gave this specific reason:

If this question can be reworded to fit the rules in the help center, please edit the question.

  • 20
    \$\begingroup\$ Oh god this. I am used to full-featured IDEs, and going from something like Wing IDE (for Python) or Visual Studio to the thing the Arduino people have the gall to call an "IDE" was like being punched in the face. On top of that, a significant portion of the Arduino build process is done in the java source, rather then having it do something sensible like emit a makefile, so managing your own build process is a nightmare. \$\endgroup\$ – Connor Wolf Nov 9 '11 at 7:47
  • 1
    \$\begingroup\$ I have used Eclipse with Arduino (check out arduino.cc/playground/Code/Eclipse and robertcarlsen.net/2009/10/31/arduino-in-eclipse-989 , it works really well - it's fast, clean and great shortcuts) only downside is that the first time setup can take while :) \$\endgroup\$ – Dan Dec 13 '11 at 17:09
  • 2
    \$\begingroup\$ If you have done any programming before TextMate, avr-libc, make and screen are enough. I consider myself a beginner in AVR programming but that is everything I use. It is the reading of datasheets which is confusing in the beginning. \$\endgroup\$ – tuupola Dec 29 '11 at 15:03
  • \$\begingroup\$ @VisualMicro No, it's not the only complete alternative. See my comment below about Stino. \$\endgroup\$ – Marnen Laibow-Koser Jan 31 '13 at 19:56
  • 1
    \$\begingroup\$ The Arduino for Visual Studio Pro and Atmel Studio 6.1 plugin is a complete alternative to the Arduino Ide supporting standard or custom hardware, compile, upload, burning of bootloaders, programmers, expert mode library editing, multiple serial monitors, intellisense, and many other options for both novice and advanced users. Install is under 10 mins. Also includes Arduino examples explorer and optional Arduino USB debugger \$\endgroup\$ – Visual Micro May 17 '13 at 1:39

17 Answers 17

43
\$\begingroup\$

Warning, a long-winded explanation is forthcoming. I'd like to clear some misconceptions that I think you're having.

The Arduino is really two things.

  1. A collection of C/C++ libraries compiled with avr-gcc and
  2. A small bootloader firmware program which was previously programmed onto the chip from the factory.

Yes, the Arduino IDE basically wraps avr-gcc - the AVR C compiler. Your projects, or "sketches", incorporate the mentioned Arduino libraries and is compiled with avr-gcc. However, none of this has anything to do with how anything gets written to the board. How these sketches are deployed is a bit different than usual.

The Arduino IDE communicates with your Arduino over the usb-to-serial chip on the board and it initializes a programming mode that the bootloader understands and sends your new program to the chip where the bootloader will place it in some known location and then run it. There is no "avr library which does the actual writing" - it's just the Arduino IDE opening a serial port and talking with the bootloader - this is how your debug messages get printed to the IDE during runtime as well.

Any alternative IDE will have to be able to do this same serial communication with the bootloader. Arduino is easy because of all the libraries they already provide you with and one-touch program-and-run from the IDE. I honestly don't think it gets any easier, or more user friendly. They've abstracted all the details of the AVR micro-controller and the building/deploying process.

The alternative would be something like avr-studio (which also uses avr-gcc for its compiler) and an ICSP programmer (which is an additional piece of hardware that you have to buy). You aren't provided with much other than some register definition header files and some useful macros. You also aren't provided with any bootloader on your AVR chip, its just a blank slate. Anything you want to do with the microcontroller, you'll have to go in depth and learn about its hardware peripherals and registers and move bytes around in C. Want to print a debug message back to the PC? Write the UART routine for print() first and open a terminal on your computer.

A step lower from this you're writing code in an text editor and calling avr-gcc and avr-dude (programming command line tool) from a Makefile or command-line.

A step lower from that and you're writing assembly in a text editor and calling the avr-assembler and avr-dude.

I'm not sure where I'm going with this, I just think that the existing IDE and Arduino is absolutely genius and perfect for a beginner - their claim to fame is user friendly-ness. Maybe not the answer you're looking for, learn the work flow and make something cool with it.

\$\endgroup\$
  • 2
    \$\begingroup\$ Not the answer I was expecting, but really cleared up my understanding of the device. Thanks \$\endgroup\$ – n0pe Nov 9 '11 at 12:59
  • 4
    \$\begingroup\$ The arduino IDE is actually Three things. The C(++) libraries, a piece of hardware, and a bunch of java code that mushes the libraries into your written code somehow just before compile-time. \$\endgroup\$ – Connor Wolf Nov 10 '11 at 5:10
  • 21
    \$\begingroup\$ The Arduino build process is great. However, it is (at this moment) irrevocably bound to the Arduino's flaming pile of crap text editor. What I believe the OP wants (and I would not mind either), is a way to call the arduino build process from within another IDE. As it is now, the only way to execute an Arduino build is to click the button in the IDE. It's not scriptable. \$\endgroup\$ – Connor Wolf Nov 10 '11 at 5:12
  • 6
    \$\begingroup\$ This answer is slightly mistaken. The arduino ide does not provide its own capability to upload via the bootloader on the chip, instead it uses a command line tool called avrdude to do that. Just as with avr-gcc, avrdude is not an arduino product and is fully available for other IDE's or simple Makefiles to use. \$\endgroup\$ – Chris Stratton Aug 21 '12 at 22:39
  • 1
    \$\begingroup\$ @ChrisStratton, feel free to edit to correct mistakes/ignorance. \$\endgroup\$ – Jon L Aug 22 '12 at 2:17
15
\$\begingroup\$

Check out this page http://www.arduino.cc/playground/Main/DevelopmentTools There is several ide's and even a Visual Studio plugin

\$\endgroup\$
10
\$\begingroup\$

I use SublimeText as my primary text editor, so I was very happy to find Stino, which is an Arduino plugin for SublimeText. It's a complete replacement for the Arduino IDE (though you do need to have a copy of the Arduino IDE so Stino can find the libraries). It's got a few bugs, but is quite usable. I've hardly touched the Arduino IDE since discovering Stino.

\$\endgroup\$
  • \$\begingroup\$ @clabacchio When I get a compliment and no upvote, I generally assume people are unfamiliar with the voting concept. And I didn't flag anything, so I don't know what you're talking about here. \$\endgroup\$ – Marnen Laibow-Koser Mar 6 '13 at 22:53
  • \$\begingroup\$ Sorry I got a flag on that comment and for some reason I thought it were you flagging your own post. Nevermind :) \$\endgroup\$ – clabacchio Mar 7 '13 at 8:02
  • 3
    \$\begingroup\$ I just want to add another voice to this sentiment. SublimeText is really nice, and this Stino add-on is the real deal. \$\endgroup\$ – Steve Cooley May 11 '13 at 16:23
  • 2
    \$\begingroup\$ This is absolutely made of awesome. I already use sublime text, and this means I can entirely ditch the arduino application. \$\endgroup\$ – Connor Wolf May 16 '13 at 9:53
  • \$\begingroup\$ And there's also mcduino for Atom. \$\endgroup\$ – Marnen Laibow-Koser Jan 5 '16 at 20:02
5
\$\begingroup\$

Coincidentally I've heard about this new IDE some days ago called MariaMole: http://dalpix.com/mariamole


Curiously, Maria-Mole is the name of a very popular candy in Brazil:

enter image description here

\$\endgroup\$
  • \$\begingroup\$ Cool! I look forward to trying this when a Mac version is available. \$\endgroup\$ – Marnen Laibow-Koser Jan 31 '13 at 21:16
4
\$\begingroup\$

Yeah, creating an "Arduino IDE" is basically about putting a front-end in front of avr-gcc and avrdude. There are actually quite a few other choices besides the "official Arduino IDE." One that might be of interest is the Eclipse based AVR environment:

http://avr-eclipse.sourceforge.net/wiki/index.php/Plugin_Download

\$\endgroup\$
  • \$\begingroup\$ There's Eclipse as well. It starts with the AVR support someone else mentioned, but you can load the Arduino library so that you can write Arduino code. See arduino.cc/playground/Code/Eclipse \$\endgroup\$ – ViennaMike Nov 13 '11 at 18:06
4
\$\begingroup\$

Personally I recommend (since I wrote it ;) ) UECIDE. It was originally based on MPIDE for the chipKIT boards, which itself was based on version 0023 of the Arduino IDE, but there's not much of the original code left now, it has all been re-written.

It supports all the Arduino boards, plus chipKIT boards, Launchpad, Maple, and a whole host more.

enter image description here

\$\endgroup\$
  • \$\begingroup\$ Looks promising... \$\endgroup\$ – horta Aug 4 '14 at 14:38
  • \$\begingroup\$ UECIDE has come on a long long way since then. You should check out the latest beta version... \$\endgroup\$ – Majenko Nov 19 '18 at 18:52
4
\$\begingroup\$

Also, you can try browser-based/online IDEs for Arduino, such as Codebender.

\$\endgroup\$
  • \$\begingroup\$ Neat! Those look worth playing around with. \$\endgroup\$ – Marnen Laibow-Koser Feb 13 '13 at 20:09
  • \$\begingroup\$ +1 for telling us about Codebender. But could you fix the 404 error on the Wifino link? \$\endgroup\$ – davidcary Jan 3 '16 at 22:02
  • \$\begingroup\$ @davidcary: Updated answer, thank you for the note. \$\endgroup\$ – boardbite Feb 4 '16 at 20:49
4
\$\begingroup\$

Plugin Image
(source: visualmicro.com)

The free Microsoft Visual Studio and Atmel Studio Plugin is simple to use and has all of the useful features of the Arduino IDE.

Sketch code remains fully compatible with the Arduino Ide. The plugin uses the same build process and tool chain as the Arduino Ide. You choose which Arduino Ide version(s) you want to use with your projects.

Provides many additional features such as drill down into compiler errors, disassembled view (with drill down), code completion, upload via programmer or Usb.

Supports multiple Arduino versions in a single Ide. The Visual Studio version also supports the Intel Galileo.

Both Ide's support Arduino Yun Wifi/Web Server upload. There is also an optional Usb/Serial/Wifi Arduino Debugger

Atmel Studio is based on Visual Studio. Atmel Corp. are the company that make the Arduino micro-controllers. This means the Atmel Studio Ide is aware of and made for the Arduino micro-controllers.

Atmel Studio also provides other tools such as a Simulator.

Documentation and free forum

\$\endgroup\$
3
\$\begingroup\$

I recently switched from the joke that is the Arduino IDE to code::blocks-arduino. It is better suited for more complex projects with multiple sourcefiles. You have complete control over compiler flags, build target and many other things that are either missing or badly-written in the official IDE It is very similar in operation to the eclipse plugin, but not as bloated as eclipse code::blocks-arduino a stand-alone build. It comes with several useful tools for uploading and debugging, such as a SUPER COOL AND USEFUL serial monitor with some really nice features like direct i2c (twi, whatever you want to call it) debugging, serial capture and csv output, etc.

compiled for windows, with linux sources available http://www.arduinodev.com/codeblocks/

A "middle" approach would be MariaMole, which unfortunately is windows-only, but has a lot of the simplicity of the official IDE, but with a lot of the features of a "classic" IDE. a notable difference between the two is MariaMole uses .cpp and .h files while code::blocks-arduino uses .ino like the official IDE.

windows only ;( http://hackaday.com/2012/11/29/mariamole-an-alternate-arduino-ide-aimed-at-advanced-users/

\$\endgroup\$
  • 2
    \$\begingroup\$ For all the Arduino IDE bashing going on here, people forget that aim of "Arduino" (the IDE, bootloader/libs, HW) was to "dumb it down" for folks who are beginners on such things! For that, Arduino did a great job. However, once people graduate beyond the initial candy-licking stage (as most do), avr-gcc, avr-libc, makefile, simavr, gdb and simple editor like nano, vi or even emacs, can give one endless joy of working with the Arduino. Or, with plain baremetal AVR 8-bit uC in their self designed (or at least, assembled) boards. So, Code::blocks is perhaps a good option, yet one of many. \$\endgroup\$ – icarus74 May 16 '13 at 9:28
  • \$\begingroup\$ The problem isn't that the Arduino IDE is simple and easy to use; that's fine. The problem is that its UI is poorly designed. Alternatives like Stino are as simple but have a better UI. (I'm referring to the Arduino UI as it was in 2013. There seem to have been some improvements made since.) \$\endgroup\$ – Marnen Laibow-Koser Jan 9 '18 at 6:31
2
\$\begingroup\$

Jon L:s anser sums up the Arduino quite well and since he just touches on the alternatives I could clarify them a little bit more.

  1. Arduino with the bootloader.
  2. Windows pc loaded with avr-studio and WinAVR (gcc), and maybe a jtag to flash the device (AVR JTAGICE mkII)
  3. The gnu toolchain (on either Linux or Windows) that is using WinAVR and a AVR JTAGICE mkII.

But please note that just as Jon L states, alt1 is basic and easy since it removes most stuff from your face. Turn on a LED, call the turnOnLED function in the lib.

Alt2. You get some help about the chip and a more classic IDE, but you have to do most of the things your self.

Alt3. You have to do everything your self but you get maximum power over your environment.

So now you can select what kind of development you would like to do, one good thing with the AVR stuff is that the tools like the jtag is quite affordable so it is a quite cheap platform to work with regardless of what level you use.

And since it is a AVR on the Arduino, if they have a jtag connector you can use alt1,2 and 3 on the Arduino boards.

\$\endgroup\$
2
\$\begingroup\$

You can use emacs (or similar) for writing code, and make for building and deploying it. The arduino packages ships with makefile samples and stubs for doing all the things.

\$\endgroup\$
2
\$\begingroup\$

EngBlaze just did a tutorial on using Atmel Studio (used to be AVR Studio) to do exactly this. Tutorial: Using Atmel Studio 6 with Arduino projects

\$\endgroup\$
2
\$\begingroup\$

Eclipse is a great alternative and now with the eclipse plugin you can find at eclipse.baeyens.it it installs in less that 15 minutes on windows mac and linux. It even has a serial monitor.

\$\endgroup\$
2
\$\begingroup\$

There really are separate things you need:

  1. A code editor.
  2. A toolchain and compiler.
  3. A bootloader.

The standard all-in-one Arduino IDE comes with an insanely basic editor, something you'll quickly outgrow. I recommend replacing the editor first, continue to reply on step 2 and 3 from the basic package.

Once you're ready to venture beyond, see http://playground.arduino.cc/Main/DevelopmentTools for tools that can take on all three major functions.

\$\endgroup\$
1
\$\begingroup\$

What Dan said (in a comment to the question): Eclipse is a full featured IDE that works very well with Arduino. (Seconding his setup comment, too, though). But the easiest way to set it up might be to port someone else's working installation to your own machine to get a working config, and start tweaking from there.

\$\endgroup\$
0
\$\begingroup\$

I have been using this Makefile. It takes care of most of the process for you. Then you just write a simple local makefile to provide board specific details. There's really great documentation for how to use it. Then I just use my preferred text editor to write code in C or C++, compile it with my simple local makefile. Uploading is also dealt with by the makefile I linked: just call "make upload".

This is a nice solution because you can then use whichever text editor you want. It allows you to easily link all the arduino libraries, plus any local libraries that you have.

\$\endgroup\$
-1
\$\begingroup\$

This is an old Ide that I've found very fast and flexible. It can program Arduinos, and also Arduino clones like Paperduino or tinyUSB. You can also check the USB or serialports, test fuses and lots of other stuff in an easy way.

https://code.google.com/archive/p/avr-project-ide/

\$\endgroup\$
  • \$\begingroup\$ This is not a particularly good recommendation -- the project has not been updated since 2011, and will not work with many newer Arduino-branded boards. (In particular, it will not support any ATmega32U4 boards, like the Arduino Leonardo or Micro, nor will it support ARM boards like the Arduino Due or Zero.) \$\endgroup\$ – duskwuff Oct 16 '17 at 17:40

Not the answer you're looking for? Browse other questions tagged or ask your own question.