Eclipse-based IDE for Host Porting, Abstraction, Simulation, Testing and Conversion

Application Common Operating Environment (AppCOE™) is a framework of common architecture that promotes interoperability and cross-platform capabilities among systems and devices. It is built on the powerful open source Eclipse-based framework and integrates all of MapuSoft’s tools: OS Changer®, Cross-OS Development Platform™, Cross-OS Hypervisor™, Linux OK™, OS Simulator™, App/Platform Profiler™ and OS Version UpKit™. Embedded C, C++ and Ada applications can be standardized on AppCOE to allow the applications to interoperate and run seamlessly on a single platform.

Why Use AppCOE?

  • Supports multiple embedded development languages (C, C++, and Ada)
  • Proven, robust, industry standard interfaces allows legacy and new applications to talk to each other in a safe and secure environment
  • Develop applications using various MapuSoft OS Interfaces (VxWorks®, Nucleus®, ThreadX®, pSOS®, Linux/POSIX, micro-ITRON and Windows®) and run on various target operating systems
  • Standardize multiple RTOS applications, allowing them to interoperate and run seamlessly on a single platform
  • Negates future porting efforts to save money and time
  • Provides freedom, protection and stability to embedded applications
  • Concentrate on enhancement of your product functions rather than worrying about the hardware, RTOS and tools becoming obsolete

Read More

Here is more information about each tool found in AppCOE:

Cross-OS Development Platform
Develop Once to Deploy on Multiple Platforms with Ease
Cross-OS Development Platform is a C/C++ source-level virtualization technology that provides a robust and industry standard OS interface architecture for flexible real-time application development, while allowing the user to protect the software from being locked to one OS. This negates future porting issues because the software will support multiple operating systems and versions from the beginning. It also eliminates the risk associated with the OS selection process, since the same application can be tested on multiple platforms for comparison and won’t be tied to the chosen OS. Learn more on the product page >>>

OS Changer Porting Kit
Rapid Software Reuse on any Operating System with Performance Optimization
OS Changer is a C/C++ source-level virtualization technology that allows you to easily re-use your software developed for VxWorks, pSOS, Linux/POSIX, Windows, Nucleus, ThreadX and μITRON on another OS, while providing real-time performance. It eliminates the manual porting effort, saves money and shortens the time to market. Learn more on the product page >>>

OS Abstractor
Provides an important level of abstraction to your application
OS Abstractor was designed for embedded application development and provides an important level of abstraction to your application. It also provides performance enhancement features like re-using kernel resources and allowing optimization of the abstraction code that is specific to your application. OS Abstractor also provides software design abstraction without affecting your application’s performance.Learn more on the product page >>>

OS Simulator
Develop on a Host Machine without the Target Hardware
OS Simulator allows engineers to develop and test embedded applications on Windows or Linux host environments. OS Simulator eliminates the need for the original OS, as well as the requirement for expensive target hardware during development. Without the need for those components, development and testing can begin much earlier. The result is lower licensing costs, reduced hardware requirements and a shorter time to market. OS Simulator also provides a virtualized test platform to simulate a system of applications interacting with each other on one or more CPU cores through simulated devices. Optionally, OS Simulator is available with source code to simulate embedded applications integrated with native tools/software on Windows or Linux target environments. Learn more on the product page >>>

Cross-OS Hypervisor
Consolidate Applications Developed for Multiple OS on a Single OS Platform
Cross-OS Hypervisor™ is a next-generation hypervisor that eliminates the need for multiple operating systems by providing the OS functionalities required by the applications. This design ensures that applications are not locked into a particular OS platform and also simplifies development, reduces bill-of-material costs, and utilizes the system resources more effectively. Cross-OS Hypervisor is redefining virtualization from wrapper-based implementations to source-level virtualization, thereby bypassing multiple layers of OS and hypervisor schedulers to gain performance increases. Learn more on the product page >>>

Linux OK
Linux Optimization Kit: Increase Performance of Linux Applications
Linux OK™ (Linux Optimization Kit) framework provides several kernel and application specific optimization features all aimed at increasing CPU performance, speeding up boot-time and reducing memory footprint for Linux applications. The included POSIX Interface allows better coverage and portability, meaning one code base for multiple POSIX variants. Learn more on the product page >>>

OS Version UpKit
Upgrade Your OS Version Without Manual Porting Effort
OS Version UpKit™ allows you to easily upgrade to a newer version of your OS. Learn more on the product page >>>

App/Platform Profiler
Allows you to identify performance bottlenecks and compare performance metrics on various target environments. The data is collected offline from the application and platform. It is viewed graphically with charts and graphs to find bottlenecks system wide or regarding a specific task.Learn more on the product page >>>

Product Diagram



Click here for FAQ´s

Frequently Asked Questions about AppCOE

Q: What value does AppCOE provide?
A: With Application Common Operating Environment(AppCOE ) you can easily port, abstract and optimize your code on a host machine and run the application on different target platforms. AppCOE leverages the existing OS Changer and OS Abstractor technologies while adding advanced code optimization capacities on multiple OS environments. AppCOE provides users an easy-to-use graphical user interface that is integrated with the Eclipse® based CDT environment. More information can be found here:

Q: Why should I develop on a host instead of the target platform?
A: Developing on a host will provide you the following benefits:

  • Don’t be constrained by a limited availability of your target hardware
  • Begin developing the application before the hardware is available to improve your time to market
  • Simulate your application on a host for easy testing, verification and presentation

Q: Why should I use a unified architecture for development?
A: Using a unified architecture will provide you the following benefits:

  • Reduce the learning curve by using a standard IDE across multiple operating systems
  • Re-use same code base across multiple OS to reduce time consuming maintenance
  • Eliminate manual updates to applications when upgrading to newer versions of OS

Q: Why should I use the Eclipse IDE?
A: Using the Eclipse IDE will provide you the following benefits:

  • Offers state-of-the-art CDT for productive development
  • It’s the industry de facto standard
  • Offers open source plug-ins for economical development

Q: How should I choose between the standalone (full-package) or code optimizer solutions?
A: The standalone version is now called the Full Library Package option and can be generated from AppCOE. You can also generate Optimized Code (using Code Optimizer) or Standalone binaries. Both options are provided with full source code without obfuscation. Here are a few technical points about the choices:

The standalone (or Full Library package) library includes the standalone products with all the features. Integration to an Eclipse-based IDE for host development is possible by purchasing the standalone solutions for the host platform. Using this option requires the necessary integration with your tools. The package is provided with a standard one-size-fits-all source code library and is manually configured via usr.h file. Standalone solutions are used as a library and code size and performance optimizations are done by the compiler tools. Some integration is required to tie one or more libraries to the applications. Sample demos are provided showing target OS specific initializations (excluding the board level initializations) and sample project files are supplied for some tools.

The Code Optimizer includes access to the AppCOE IDE which allows development, porting and debugging of applications on Linux & Windows host platforms using Eclipse framework without a need for the target hardware. Porting legacy applications under a host environment is much easier than porting on the actual target. This option allows for graphically configuring & integrating multiple OS Abstractor & OS Changer solutions. The source code generated is based on the level of API usage by the application for a more custom solution and to increase the application performance. Also available is the option to select individual APIs for execution speed optimization in addition to other compiler optimizations. The generated interface code can either be made part of the application or can be a standalone library. This option provides automatic generation of target OS specific initialization code (excluding board level initializations) and automatic generation of project files (make/visual C++/eclipse/etc.).

Q: What source code plug-ins are available for the Mapusoft Eclipse based IDE?
A: AppCOE is based on eclipse framework and as such there are innumerable plug-ins available which can be readily used or easily integrated with AppCOE if needed (

Q: What is required to add target support for my In-house OS to AppCOE?
A: Adding support for an in-house OS can be easily done by our India development team for a nominal fee. Validation can also be done by MapuSoft or yourself. In order to estimate the work, we need know more about the OS functions in your In-house OS, such as:

  • Do you support priority based scheduling?
  • Is there a way to change thread priority of a running task?
  • Is there a way to manually suspend/resume a thread?
  • Is there a way to manually relinquish thread control?
  • Is there a way to get the current thread id?
  • Do you have a basis semaphore support?
  • Do you have a basic message queues support?

We also need to know the OS Interfaces that you need supported (e.g. POSIX, uITRON, VxWorks, etc.) on top of your target In-house OS so that you can either migrate code to your In-house OS or develop new code using those Interfaces. For example, if your In-house OS needs to run Linux code, you would need POSIX/Linux Interface support for your target In-house OS.

To support the AppCOE Profiler feature, two APIs (related to higg resolution) need to be ported to run on your target In-house OS. These APIs need access to the hardware hi-res clock on your board. This is something you can easily do yourself or ask us to do it for you, if you wish.