Array Runtime is the core execution environment designed with primary focus on scalability and performance. Its unique small footprint allows for high flexibility in deployment as it can scale from a mobile phone up to large Unix clusters.

• Generic interface-based constraint solver framework.
  All Array Runtimes are based on a single detailed and well-documented interface rather than proprietary data formats, guaranteeing easy integration and a safe migration path to support future versions and new features.
  
  The design of the API is so that the nature and combination of models and engines in a given implementation is completely transparent to the application developer. This promotes quicker development/deployment cycles, prevents errors and facilitates re-use of end-user applications.
• Random selection order.
  The global model view offered by the unique mathematical representation developed by Array Technology provides freedom for users to interact with the model in any order they please.
• Change tracking.
  Because the Runtime oversees the entire solution space, it can keep track of changes throughout the model regardless of the users current focus, and regardless of whether those changes are caused directly by the user or by some indirect implication.
• Advanced conflict handling.
  The Runtime effectively prevents conflicts through its complete and continuous overview of the full solution space, but also provides powerful tools to resolve explicit (forced) conflicts.
• Unique soft-selection and priority support.
  User selections can be categorized and have assigned priorities that customize the conflict handling process, effectively allowing the user to provide "hard selections" as well as suggestions or "soft selections".
• Persistency support.
  The Runtime can re-construct any given configuration based on the users selections and a product model. This works across model revisions as long as the configuration stays valid with respect to the model. When it doesn't, advanced conflict handling helps find an alternative solution.
• Run-time linking to legacy data storage.
  Models that do not exist as files, or even at all, at compile-time can be integrated into the Runtime by virtue of its interface-based architecture, and clean separation in model and engine.
• Extensive platform support.
  The Array Runtime is available on several platforms and the various interfaces are as identical as the platforms allow, minimizing the efforts required by application developers working in today's multi platform environment. The following platforms/languages are supported:
  

  - C++
  - .NET (e.g. C#)
  - COM (e.g. Visual Basic)
  - Java (including J2ME)

• Minimal footprint.
  Complexity is dealt with at compile-time, and the solution space is effectively compressed so the Runtime can be kept small and simple, making it perfect for deployment on devices with limited resources.
• Transparent Integration to 3rd party solvers.
  A side effect of the interface-based Runtime is that legacy systems can be wholly or partially re-used during implementation and migration.
• Internationalization support.
  The Runtime fully support UTF-8 encoding of all text data.
• Transparent scalable Client/Server support.
  Re-use of model data across sessions, small memory footprint and sub-millisecond response times guarantees highly scalable server implementations. Web extensions based on industry standards provide automatic support of existing load balancing, clustering and other scalability technologies.

Extensions
Array Technology strives to support the entire range of applications associated with the use of a state-of-the-art configurator from modeling to run-time execution and end-user application UI. The Array Extensions is a suite of component collections for rapid, flexible and powerful UI design on a wide range of platforms.

Web

• No-code approach.
  The JSP Web Extension is a powerful collection of custom tags developed to support web based configuration applications. No programming is required to build the configurator UI, and the Extension supports explicit insertion of variables, automated layout engines, or a combination of the two. Furthermore, tags are available that control flow, layout and appearance of the final UI.
• Seamless integration with existing web applications.
  Because the Extension is not a monolithic application, it places no restrictions or requirements on existing web applications, but allow maximum flexibility with minimal effort.
• Clean separation of modeling, application programming and UI design.
  The Extension encapsulates all application code, and supports patterns to deal with groups of model variables, allowing the system integrator to focus on integration and UI design, ignoring the complexities of modeling and application development.
• Based on industry standards.
  The Extension is based on industry standards enabling the UI designer full freedom in choice of design environment while leveraging the powers of today's powerful web technologies.

Client

• Rapid Application Development.
  The Client Extension is a set of intelligent UI components that can be used to quickly embed the configurator UI in a client application.
• Customizable.
  The Extension knows how to display multiple Runtimes, handles events as necessary, but still allow the application to take control of specific tasks if desired. The controls themselves are highly customizable in terms of both functionality and visual appearance.
• Multi platform support.
  Components are available for a number of platforms:

  - Swing (Java)
  - SWT (Java/Eclipse)
  - ActiveX (Visual Basic)

Mobile

• Single-step deployment.
  The Mobile Extension allow existing models to be deployed to PersonalJava enabled handheld devices without additional application development.
• Full-featured.
  The Mobile Extension is just as feature rich as the Client Extension. The small footprint is all the more important on this platform and the primary reason we can avoid the feature-reduction commonly resorted to on mobile devices.