Earlier this year we published a demo app showcasing our port of Node.js with ChakraCore to iOS. In the accompanying [blog article](http://www.janeasystems.com/blog/node-js-meets-ios/), we talked about how Node-ChakraCore opened a unique opportunity for Node.js to work on iOS, and consequently a path for Node.js to become a viable building block for mobile applications.

The engineering team at Janea Systems has continued to work hard and passionately on this project; so today, we are excited to announce the first alpha release of [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile): a toolkit that enables developers to harvest the power of Node.js and its module ecosystem in their mobile applications. At the heart of it, is a library - available for Android and iOS - that allows an app to host a full-fledged Node.js execution environment. In addition to the core library, we have released plugins for Cordova and React Native - both also compatible with Android and iOS - which make it extremely easy to integrate the Node.js runtime into applications built using on those frameworks.

The project is still at an early and experimental stage, but you can start building your apps with it today.

And like most best things in a developer's life, [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile) is **free and open source**. :)

### The power of Node.js inside your mobile apps

With Node.js for Mobile Apps, you get a Node.js execution environment running in a background thread inside your app. This environment is well suited for business logic, advanced networking, and background processing, but it can pretty much run any code that can be executed asynchronously from the UI, while leaving synchronous UI handling to the main application thread.

To facilitate communication between the Node.js code and other parts of the app, we have implemented a high-performance messaging channel that can be used to send data back and forth. It is a low-level primitive that is effective in and of itself, but could also be used in the future to build higher-level abstractions on top of it, like cross-thread method invocations and callbacks.

For example, in a React Native app you can do:

```javascript

import nodejs from 'nodejs-mobile-react-native';
...
  nodejs.start();
  nodejs.channel.addListener('message',
    (msg) => {
      alert('Received from node: ' + msg);
    },
    this
  );
...
<Button title="Send something"
  onPress={() => nodejs.channel.send('something')}
  />
```

JavaScript code can also make direct synchronous calls into native code (Java, Objective C, Swift) and get calls back from it, by means of Node's native add-on APIs (the V8 API and N-API are both available).

And of course, you can use modules. We have done a good amount of testing with PouchAlbum - our demo app - which includes more than 300 modules. So even though there's more work to be done to fully assess and ensure compatibility of the module ecosystem, there are reasons to be happy about the current state of affairs.

### A highly-compatible Node.js engine under the hood

Today's release of [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile) is based on source code from Node.js v8.4.0.

The Android version of the core library uses the V8 JavaScript engine - much like regular Node. So it is very similar to a Linux build of Node.js, but with a few platform-specific tweaks and fixes.

On iOS, V8 cannot run because the operating system forbids just-in-time compilation; so instead of V8, we used our own port of the ChakraCore engine, on top of the integration with Node that Microsoft created in [Node.js on ChakraCore](https://github.com/nodejs/node-chakracore). ChakraCore has a well-optimized, pure interpreter mode which complies with iOS' restrictions.

On both platforms, the result is a runtime that ensures the highest level of compatibility with Node.js.

### Built for the community

At Janea Systems, we love Node.js. We have been involved with the project and its community for many years. We have been contributing to the Windows version since its early days, and have been participating in several committees, working groups and efforts at the Node.js Foundation.

With this project, we wanted to create a space where we can experiment and quickly iterate on the features that are specifically needed for Node.js as a building block for mobile applications. So, while this is technically a fork on GitHub, it is absolutely not in our intention to divide the Node.js community or antagonize the Node.js project. On the contrary, we hope that this effort will help Node.js become even stronger and more ubiquitous.

We anticipate that developers will build amazing things with these tools, far beyond what we can imagine today. So we invite you to get involved. Try the toolkit. Provide feedback, report bugs, suggest improvements, contribute code. Go build amazing new apps and radically new frameworks with it!

We can’t wait to see what you will come up with. And we look forward to working with the community towards making mobile app development more accessible, productive and fun.

To get started, visit the [Node.js for Mobile Apps website](https://code.janeasystems.com/nodejs-mobile).

Harness the power of Node.js inside your mobile apps. Runs on Android and iOS. Supports native, React Native and Cordova applications.

Node.js for Mobile Apps: full-fledged Node.js for Android and iOS

Announcing Node.js for Mobile Apps: a full-fledged Node.js runtime for Android and iOS

Janea Systems continues to bring world-class software engineering to developers and enterprise companies across the globe. Now, we’re ready to launch the world's most advanced Redis-compatible cache and datastore for Windows. It’s called **Memurai**.

Developers know all too well that the frustrating search for a supported, up-to-date Windows build of Redis always ends with little more than a complicated and inefficient workaround. No more. Memurai puts an end to non-native solutions that fail to fully integrate the world’s most popular NoSQL datastore into their Windows infrastructure.

### **SEAMLESS AND WINDOWS-NATIVE**

Memurai is fully Windows-native and compatible with Redis, with performance and reliability that developers need and demand. It’s fast, flexible, and fine-tuned for optimal performance.

With Memurai, you won’t miss any functionality since its core is based on Redis source code. That means developers will still have access to the features that make Redis such a popular and helpful cache/datastore.

Memurai is a game changer. Engineering teams with long-term investments in Windows infrastructure will be able to get up to speed with Memurai quickly. Huge datasets and mission-critical workloads are safe and sound within Memurai.

Memurai is scalable, supported, and reliable. It’s the only Redis-compatible cache/datastore for Windows anyone will ever need.

### **PACKED WITH POPULAR FEATURES**

Memurai supports all of Redis’ most popular features, including:

*   Persistence
*   Replication
*   Transactions
*   LUA scripting
*   Modules
*   Streams
*   API 5 eviction policies

### **JANEA SYSTEMS AND MEMURAI**

At Janea Systems, we love Redis, too. In fact, we helped write the archived (no longer supported) official Microsoft Open Tech port of Redis. However, we knew of the need for a Redis-compatible cache and datastore for Windows, so we created one.

We think you’ll love Memurai, and we’ve made installation super easy. Remember: If you’re already running Redis on Linux, you can simply replicate the data between Memurai and Redis — or use them both within the same cluster.

![](http://www.janeasystems.com/wp-content/uploads/2019/08/memurai_comparisons-1024x404.jpg)

[**\>>>READY TO TRY MEMURAI? DOWNLOAD IT FOR FREE!\<\<\<**](https://www.memurai.com/)

Meet the world's most advanced Redis-compatible cache and datastore for Windows. It’s called Memurai. 

Say Hello To Memurai: A Redis-Compatible Cache And Datastore For Windows - Janea Systems - Blog

Say Hello To Memurai: A Redis-Compatible Cache And Datastore For Windows

[Bartosz Sosnowski](https://twitter.com/bzoz_) and [João Reis](https://twitter.com/joaocgreis) of Janea Systems have made enhancements to Visual Studio Code that enable launching and debugging Node.js in the Windows Subsystem for Linux. Read the [MSDN blog article](https://blogs.msdn.microsoft.com/commandline/2017/10/27/running-node-js-on-wsl-from-visual-studio-code/) to learn more.

Debugging Node.js with VS Code and WSL

Over the last few months, Janea Systems has been working on a port of Node.js with ChakraCore to iOS. Now that things appear to be working well, we have created a demo app that showcases this work, and we’d like the feedback of the developer community to help us shape the future of the project.

> **UPDATE \[Oct 3rd, 2017\]:** The work described in this article has culminated in the release of Node.js for Mobile Apps: a full-fledged Node.js runtime for Android and iOS. Read the [announcement](http://www.janeasystems.com/blog/announcing-node-js-mobile-apps-true-node-js-runtime-android-ios/).

One of the many strengths that Node.js can claim under its belt is its ubiquity. From server to desktop to IoT, the Node.js runtime is available and generally well-supported on an [impressive list](https://github.com/nodejs/node/blob/1d60fc3aa5b7a6032665595c29bdb382bd526e43/BUILDING.md#supported-platforms-1) of operating systems and architectures.

Two major platforms, however, are conspicuously absent from the list: iOS and Android.

Why is that?

The reasons are both historical and technical. For one, Node.js was originally designed as a server platform, with assumptions that don’t always fit the app model and the unique challenges of mobile operating systems. But this reason alone would not have prevented developers from at least experimenting with Node.js on mobile. In fact, there have been a few reports already of people running Node.js on Android.

One issue, however, has completely prevented any attempts to make Node.js work on iOS: Apple does not allow Just-In-Time compilation on iOS (except for its own JavaScriptCore engine). The JavaScript engine that powers Node - Google’s V8 - relies on JIT compilation to execute JavaScript (even with the addition of the Ignition interpreter, V8 still needs to generate code at runtime, which does not comply with iOS’ restriction).

To be fair, somebody did manage to make Node work on iOS. [JXcore](https://github.com/jxcore/jxcore), a fork of Node based on version 0.10, added features specifically targeting mobile platforms and circumvented the iOS JIT restriction by adding the ability to use engines other than V8. By using SpiderMonkey in its interpreter mode, JXcore was able to run on iOS. JXcore also added other features and tooling to make Node fit well with mobile environments. Unfortunately in March 2016, Nubisa - the company behind JXcore - announced that they would no longer be working on the project. JXcore has made massive changes since the fork and meanwhile, development of mainline Node.js has continued at a dramatic pace; the two codebases have diverged so much that reconciling them is no longer practical and with JXcore still stuck at v0.10, it is clear that the project has reached a dead end.

Fortunately, other relevant efforts have emerged. Microsoft published [Node-ChakraCore](https://github.com/nodejs/node-chakracore), a friendly fork of Node which adds support for optionally using the ChakraCore engine instead of V8. Rather than modifying the Node source code to use a different engine, as JXcore did, they wrote a shim on top of ChakraCore which essentially emulates the V8 API. Thanks to this approach, the fork is much easier to keep in sync with the parent project; the two happily coexist under the Node.js Foundation and will likely be merged at some point.

Node-ChakraCore opens an opportunity for Node and iOS because ChakraCore has a well-optimized, 100% JIT-free interpreter mode. Even though it doesn’t officially support iOS at the moment, it was recently ported to macOS, which is not too far off.

The Janea team has been involved with these technologies for a while. We have been supporting JXcore for the [Thali](http://thaliproject.org/) project and we have been working closely with Microsoft on both the Windows port of Node.js and Node-ChakraCore. So a few months ago we decided to capitalize on the lessons learned from all those projects and started porting Node.js with ChakraCore to iOS.

We chose to focus on iOS first because we knew that it would be significantly more challenging than Android. With a little bit of effort, you can pretty much already run Node with V8 on Android (even though a lot more work needs to be done to make it an easy-to-use framework for mobile). It’s Node.js on iOS that truly breaks new grounds.

We have now reached a point where things seem to be working pretty well. Even though it’s still too early to publish a release, we wanted to at least share the news and show a demo.

### The demo

For the demo, we thought it would be interesting to showcase an integration of Node.js with React Native. React Native allows developers to write mobile apps primarily using JavaScript, while still having to write native iOS/Android code for things that are not covered by the framework. By adding Node.js to it, the hope is that developers will be able to do more with just JavaScript. While there are already solutions for using Node.js modules with React Native, having a real Node.js engine in the app should open up more opportunities and improve support for those modules.

The way we added Node.js to React Native is by starting Node.js on its own thread at application startup. Node and React Native each use their own JavaScript engine instance: ChakraCore and JavaScriptCore, respectively. In this particular implementation, the two JavaScript environments communicate via a combination of a REST API and WebSockets, which is a simple but effective approach that in principle allows to make calls, register callbacks, and pass JSON objects back and forth. While we chose to keep things simple in the demo, it would be easy to add some syntactic sugar on top of the REST API / WebSockets to make the interface between the frontend and backend even slicker.

The application allows the user to create photo albums and synchronize them with other users/devices. Synchronization happens between any number of devices and it works peer-to-peer, with no external server involved. Because of that, it only happens when the devices are on the same Wi-Fi network.

Node’s built-in dgram module is used for local network peer discovery, by means of UDP broadcast packets. The React Native portion of the app handles the UI. When a photo is added, it is stored in an in-memory database running in the Node layer, using PouchDB and MemDOWN. Back on the Node side, PouchDB handles the synchronization between devices. The REST API is provided by the express-pouchdb module, which starts a CouchDB compatible REST API on top of PouchDB, using the popular Express module. WebSockets is provided by the express-ws module, also on top of Express.

[Here’s a video showing the app in action.](https://www.youtube.com/watch?v=8Wx0kxWpvkY)

The demo source code is available [on GitHub](https://github.com/janeasystems/node-mobile-react-demo).

### Where do we go from here?

The possibilities for Node.js on iOS are certainly not limited to React Native. For starters, an integration similar to the one shown in the demo could be implemented for Cordova / PhoneGap (similarly to how [JXcore-Cordova](https://github.com/jxcore/jxcore-cordova) integrates Cordova with JXcore). Thali, which uses JXcore through JXcore-Cordova to provide rich peer-to-peer synchronization abilities, could certainly benefit from such a thing. Other mobile development frameworks, especially the ones based on JavaScript, could also be considered.

Of course, Node can also be added to any regular iOS application written in Objective-C or Swift. You would simply link the Node.js library with the application and add all the JavaScript code to the bundle. In your app startup code, you would then create a thread to execute the Node event loop and have it run the main script. You now have at your disposal the power of the Node.js built-in modules and the npm ecosystem.

So there are plenty of opportunities for future developments. At Janea, we intend to continue working towards making Node.js a powerful tool for iOS and Android development.

In the meantime, **we would love to hear your feedback** about all of this. How would you use Node.js on iOS and Android? What scenarios, features, or integrations would be most interesting to you? Please share your thoughts in the comments section.

For any further questions or suggestions, please don’t hesitate to [get in touch](/#contact). Also, don’t forget to subscribe to our social media channels and our newsletter, so that we can keep you posted about future developments.

Node.js breaks new grounds, runs on iOS. Port and demo courtesy of Janea Systems.

Node.js meets iOS

small_Alexis HD.jpg

thumbnail_Alexis HD.jpg

Alexis HD.jpg

Alexis

Ensuring core dependencies function correctly on the Windows platform.	

Dependency Stability

Extending Node.js support to ARM64 architecture for Windows.

ARM64 Support

Navigating open-source community dynamics for cohesive development.

Community Collaboration

Building a robust platform for corporate adoption.

Reliability for Enterprises

Addressing speed discrepancies for a seamless experience.

Enhancing Performance

Successfully eliminated frequent bugs and crashes, enhancing Node.js's stability on Windows.

Stability Achieved

Achieved a 40% improvement in file I/O speeds through our optimization efforts.

Performance Breakthrough 

Ensured core dependencies work reliably, supporting a wide range of Windows-specific applications and services.

Dependable Dependencies

Established Node.js as a reliable and preferred solution in corporate environments, broadening its reach.

Enterprise Adoption

Users can rely on native Node.js capabilities like ARM64 compatibility. 

ARM64 Adoption

When Node.js emerged as a leading server-side JavaScript runtime, it was primarily optimized for Linux and macOS environments, leaving Windows users grappling with stability and performance issues. Realizing the potential of Node.js, Microsoft demanded its high-performance and reliability on Windows to ensure widespread adoption. 
 

Find out why Microsoft had trusted Janea Systems to maintain Node.js on Windows for over a decade.

Maintaining Node.js on Windows Since 2013

Ensuring a Smooth Node.js Experience on Windows 

Navigating the transition to 64-bit computing, enhancing .NET CLR's compatibility and performance.	

64-bit Architecture Evolution

Seamlessly integrating .NET CLR with Windows Vista, ensuring continuous compatibility and efficiency.	

Windows Vista Integration 

Advancing the compiler for 64-bit support, optimizing application performance on newer hardware.

Compiler Enhancement

Rewriting parts of the garbage collection mechanism for improved memory management across architectures.	

Garbage Collection Overhaul

Enhanced .NET CLR performance for 64-bit architectures.	

Performance Optimization

Optimized the .NET team's workflow with a robust check-in management system, boosting productivity.	

Streamlined Dev Process

Achieved broad architecture compatibility, enabling .NET's use across various hardware platforms.	

Cross-Platform Compatibility

Strengthened security and system stability, paving the way for safer enterprise-level applications	

Security and Stability

Janea Systems was tasked with establishing the foundation of .NET versions 1.0, 1.1, and 2.0, making significant strides in computing architecture and application development. Working as part of the Build team, with a focus on portability, garbage collection, and performance, this project was instrumental in transitioning .NET into a new era of 64-bit computing. From the initial development phases to its integration with Windows Longhorn (Vista) this project was instrumental to .NET’s security, performance, and broad architecture compatibility. 

Discover Janea Systems' role in .NET CLR's leap to 64-bit, shaping the future of software engineering and enhancing Microsoft's platform 

Building the Foundations of .NET

We played a crucial role in establishing the foundation of .NET versions 1.0, 1.1, and 2.0, making significant strides in computing architecture and application development. Key involvements include:  

- CLR 2.0 Development: Contributed to version 2.0 of the CLR, with an emphasis on 64-bit architectures, enhancing security, and performance tuning.  
- Managed Code on AMD64: Overcoming complex architectural challenges to implement and refine the execution of managed code on the AMD 64-bit platform.  
- Windows Longhorn Integration: Managed the integration of Windows Longhorn with .NET, creating a daily test suite to ensure seamless operation and codebase integrity.  
- CLR Porting and Maintenance: Played a key role in the CLR's transition to IA64, WOW64, and AMD64, focusing on critical components like the garbage collector and the security system and enhanced cross-platform development processes.  
- OS Collaboration: Partnered with the Windows base team to tailor OS interfaces for 64-bit managed code execution. 
-Development Process Optimization: Designed and upheld a lab check-in management system, streamlining the development workflow for the entire .NET team.  

Our contributions to the .NET ecosystem have supported its utility and efficiency across various platforms. We've empowered developers with a robust foundation for building advanced applications by optimizing the CLR for diverse architectures and streamlining development processes. 

Building the Foundations of .NET 

We worked on the client components of Microsoft SharePoint, which also shipped with Office XP. We were responsible for the core architecture of the project. The architecture facilitated the integration of SharePoint Portal with the Windows Shell and Office, and supported various servers.







Client Development & Core Architecture 

Janea Systems developed various features for Microsoft’s digital media products: 

- Zune.net website, including the Silverlight video player. 
- Ported the service to Windows and 64-bit. 
- Deployed automation and other process improvements. 
- Architected storage and management of high-business-impact security-sensitive data. 
- Architected features for the integration with Bing. 

Feature Development

Our work for Wilderness Labs included:

- Porting the Mono .NET runtime to the NuttX RTOS.
- Continued feature and bug fixing work around microcontroller and operating system
- Implemented new Mono AOT compilation backend for ARM Thumb, based on LLVM framework.
- Implemented new STM32 F7 machine, based on Cortex-M architecture on QEMU, including QSPI emulation, along other peripherals.

Engineering product development

Defined, architected & delivered common standards for a Web Services architecture to support & handle MPS (Bank Consortium) migration to X-Platform open protocols for security, transactions, reliability & more. Developed extensions to implement support for certs, digital signatures, session management etc.


Banking Consortium (MSFT Consulting)

Founder & Chairman of the Board

large_Janea Systems OG Image No Text.png

medium_Janea Systems OG Image No Text.png

small_Janea Systems OG Image No Text.png

thumbnail_Janea Systems OG Image No Text.png

Janea Systems OG Image No Text.png

Janea Systems is a software engineering consultancy, serving the enterprises that drive global innovation for over two decades. We help our clients build and optimize technologies used by millions of developers and billions of consumers. 

Projects

Related Blogs

Let's talk about your project

Let's talk about your project