embedXcode - Xcode template for embedded computing boards

I just stumbled upon embedXcode, an Xcode template for embedded development. I see some rather old threads on the community forum but the plugin seems very much alive. As I spend a lot of my time in Xcode (and not a big Atom fan) I was wondering if this was at all supported?

Does anybody have experience with it? Does it work well for the newer generation Particle hardware?

Link: https://embedxcode.weebly.com

Let me ping someone that might be able to help, @rickkas7 or @ParticleD are you able to assist?

I have no used it, but it sounds interesting. I give it a try and see!

1 Like


I have used embedXcode and am a big fan as Xcode is a better IDE for sure. I have asked the embedXcode folks to support Particle and they are willing - but there is a problem. embedXcode has these requirements for board support:

  1. The board or the programmer is supported by a Processing-based Wiring-derived Arduino-like IDE which works on macOS 10.12 Sierra.
  2. The tool-chain, the SDK and the utilities (like the uploader and the debugger) run natively on macOS 10.12 Sierra.

Since the Particle SDK is not 100% local, they can’t support it.

Having said that, wouldn’t it be great to be able to write, compile and flash code w/o connection to the Internet? Especially for those devices like the Electron that might have their own connectivity?


What parts are not open source? Or are you just meaning the code upload?


Sorry, to be clear - the requirement is local not open source. When you verify or create the .bin files to flash your device, that work is done in Particle cloud servers not local. embedXcode requires a 100% local tool chain.


You can compile completely locally and flash by USB or JTAG using the gcc-arm local build chain.




Hmm, is that new news? I know that the person behind embedXcode @rei_vilo has been on these forums in the past lobbying for support for local building. I know that Po-Util was touted as an option but it would not be one officially supported by Particle.

If there is a resolution here, it would be a great alternative for Mac users.



Hi @chipmc

There has always been a local-build gcc-arm and makefile toolchain path available, since the very beginning of Spark Core, so this is not new news.

It does not use a “Processing-based Wiring-derived IDE” but instead relies on more industry-standard solutions (gcc-arm and makefiles), which may be where the disconnect is. Basically Particle does not use the Arduino IDE but has several of its own: the Cloud browser-based IDE, the atom-based IDE with cloud compile, and the full local gcc-arm toolchain. The last two run on a Mac (I do it all the time) but don’t use embedXcode.



Ah, that makes sense. I had thought the issue was local but is may well be the tool chain.

Thank you for the explanation.


For its Particle-Compatible RedBear Duo, RedBear has done an excellent job on providing a truly Arduino-compatible environment as an option to the Particle web IDE.

Now that RedBear is joining Particle, let’s hope the Arduino support and compatibility RedBear developed for the Duo will be shared and implemented on all the Particle boards.

Today we’re excited to share that RedBear is officially joining the Particle family. Our teams have been collaborating since the launch of the Duo and we quickly realized the potential of working alongside a company that shared the same vision as our own. Particle, the company behind the Photon and the Electron (Wi-Fi and cellular IoT developer boards), is an incredibly aligned with our goal to help developers be successful in building connected products.

Out of curiosity, what is it about the Arduino IDE that makes you prefer it over the tools Particle offers (Web, desktop, CLI)?

To put it differently, what could Particle change about its existing toolset to make it do the things you want it to, and why?

You can refer to SparkCore Programming with Arduino IDE, Local building for Core+Photon, Local Build: How to Specify Variables in the Makefile?.

The main challenge is, each time I try to use off-line build and report issues, I receive an answer months after, when the main tools (including macOS, IDE, and make tool-chain) have already changed. If I remember correctly, Particle uses a structure of the project with a makefile for each library, which differs from the single makefile for the whole project Arduino and RedBear rely on.

I managed to have a single makefile for the first board, Spark Core, but not for the new ones, Particle Photon et al.

Now, it looks like Particle is focusing on companies and the on-line IDE fits their needs. For all the IoT projects, I prefer to use a local server. This was especially true last October 21, 2016 during the the massive internet outage: I couldn’t use any online IDE as I posted DNS DDoS, IDE and IoT.

Though I’d love to go through all those topics, some are over two years old. I’m worried that what was written then might no longer be the case now. I was hoping to get a quick & simple “here’s what’s missing right now, which the Arduino system does offer”.

Summarizing those topics/comments, it seems that you’re primarily asking for a way to compile locally? If so, does this have to be “Arduino compatible”, or would it serve more as a back-up in case the internet goes whacky?

I know, those topics are rather old and pretty much like the Loch Ness: everyone talk about her but nobody has seen her yet. That’s why I decided to stop exploring Particle and supporting its boards.

The Arduino compatibility was claimed at the initial KickStarter campaign but has never fully materialised. The claim for a 100% local build is three-fold: be independent from internet, keep code and libraries at home, enjoy greater flexibility.

The RedBear implementation shows a 100% local build is possible, and not exclusive of today’s cloud-based solutions.

I know “Arduino compatibility” was mentioned during that campaign, though I never truly grasped what that should entail. Does it mean it works in the Arduino IDE, does it mean it runs code in a similar way an Arduino does, does it use a library system like an Arduino, is it the general concept of ease of use? What exactly is “Arduino compatible” meant to be?

Furthermore, I never really understood this whole concept that Arduino is the “holy grail” of IDEs, or dev platforms. I get that they were the first, and they make some cool stuff for sure, but it doesn’t mean they’re perfect.

What I’m specifically looking for is features that Arduino offers that don’t yet exist on the Particle platform.
What does it do?
Why is that better than X from Particle?
How would you like to see Particle improve on this? (Without saying “make it work with Arduino”).

Local compilation is a great example of this:

  • It allows you to compile code offline.
  • It’s ‘better’ since you’re not tied to the internet, can store code offline, and offers a greater level of flexibility.
  • It’d be nice if Particle came up with an easy to use way to allow for local compilation.

Mind you, local compilation has always been possible, since all the code is open-source, and instructions are provided. That said, that’s aimed at a more technical audience, since the steps involved to get that up and running can be a bit advanced.
The Web IDE and local IDE (with it’s online compilation) make this a great deal easier, and as such are targeted towards more ‘novice’ audience. The CLI is the in-between, which lets you use all your own dev tools, while still taking advantage of the cloud compiler.

I do fully agree that it would be a really nice addition if there was an easy way to use offline compilation though, which is why I’ve been pushing for that quite a bit lately :wink:


By Arduino compatibility, I was expecting

  • Compliance with the boards package mechanism and content for installing and using the boards,
  • Similar boards.txt and platform.txt files with the parameters for local build,
  • On top of the general look-and-feel of the C++ dialect, libraries and APIs.

I’ve implemented support for the most popular boards that comply with the above mentioned specifications on embedXcode. The closest board is the RedBear Duo, which is compatible with Particle and meets all of the three requirements.

I’ve been exploring the CLI options for Particle, but each time I faced issues. When I reported them, I did get an answer, but months later, so macOS, Xcode and GNU tool-chain had evolved in the meantime, not to mention new releases of the Particle SDK. This situation is actually very similar to the mbed SDK, with the same consequences.

As Particle has pioneered IoT, adding that additional choice as an option would enlarge its audience and reinforce its leadership. Leveraging the know-how of acquired RedBear could speed the process up.