SolidKosmos expertise

At SolidKosmos, we specialise in fault-tolerant computing. We provide EDA tools and SW/HW solutions for functional verification and the design of FDIR techniques in complex computing systems. Our team brings deep experience in fault injection, redundancy schemes, and system-level reliability analysis across various domains. Our solutions are built to meet the requirements of space, automotive, avionics, and supercomputers, and other safety-critical sectors.

Fault injection

What is fault injection?

Fault injection is the capability of a system to continue functioning correctly even in the presence of faults, such as hardware failures, software bugs, or environmental disturbances like radiation. Rather than failing catastrophically, a fault-tolerant system detects, isolates, and recovers from faults to maintain operation.

In critical systems, where uncontrolled failure is not an option, fault tolerance is essential for ensuring safety, reliability, and mission success. Whether it’s an autonomous vehicle, a medical device, or a satellite, a fault can have severe or irreversible consequences. Fault tolerance enables systems to meet high dependability standards and operate safely in unpredictable conditions.

Fault-tolerant computing is essential in sectors such as:

  • Space – Satellites, deep-space probes, launch systems
  • Automotive – ADAS, autonomous driving platforms
  • Avionics – Flight control systems, safety-critical avionics
  • Rail – Train control and signalling systems, power electronics
  • Medical – Life-support and diagnostic equipment
  • Industrial – Automation, robotics, and critical infrastructure
  • HPC – Supercomputing clusters operating at extreme scales

Fault tolerance is achieved through techniques such as:

  • Hardware Redundancy – (e.g. Triple Modular Redundancy)
  • Information Redundancy – (e.g. Error Detection and Correction Codes)
  • Fault Detection, Isolation, and Recovery strategies – (e.g., built-in self-check)

At SolidKosmos, we specialise in dependable computing systems.

We provide electronic design automation (EDA) tools and SW/HW co-
design solutions for functional verification and fault-tolerant computing.

Our team brings experience in fault injection, SW, HW, and information
redundancy techniques, and system-level reliability analysis across various
domains.
Our solutions are built to meet the requirements of aerospace, automotive,
avionics, and other safety-critical sectors.

Functional verification

What is functional verification?

Functional verification ensures that a computing system behaves as intended under all operating conditions, including in the presence of faults, software bugs, or external disturbances. It validates that both hardware and software meet their specifications and comply with safety and reliability standards before deployment.

In safety- and mission-critical systems, failure is not an option. Functional verification is essential to:

  • Detect design flaws early
  • Validate fault tolerance and FDIR (Fault Detection, Isolation and Recovery) mechanisms
  • Ensure compliance with certification and industry standards
  • Build trust in system reliability and resilience under fault conditions

Functional verification is applied across many sectors where high dependabity is required, and is aligned with domain-specific standards:

  • Space systems – to validate resilience against radiation effects
    – Standard: ECSS-Q-ST-60-13C (Radiation Hardness Assurance)
  • Automotive systems – for safety in ECUs, ADAS, and autonomous driving systems
    – Standard: ISO 26262 (Functional Safety)
  • Avionics – for verification of hardware and software in flight-critical systems
    – Standards: DO-254 (Airborne Hardware Assurance), DO-178C (Software Assurance)
  • Rail systems – for fault-tolerant signalling and train control software/hardware
    – Standards: EN 50128, EN 50129
  • Medical devices – for validating safety mechanisms and managing clinical risk
    – Standard: ISO 14971:2019 (Risk Management for Medical Devices)
  • Industrial automation – to ensure system robustness, safety integrity, and fault handling
    – Standard: IEC 61508 (Functional Safety of Electrical/Electronic/Programmable Systems)
  • High-Performance Computing (HPC) – to study and mitigate soft errors and bit flips in compute-intensive workloads
    – Practice: Fault Emulation Techniques for Resilience Analysis & Fault Monitoring

A key method in functional verification is fault injection testing, which involves deliberately introducing faults to observe and validate the system’s response. Fault injection can be executed with the following techniques: 

Simulation-Based Techniques

  • Software-level injection (e.g. variable corruption, memory faults)
  • RTL/netlist-level faults (e.g. bit flips, stuck-at, control path corruption)

Emulation-Based Techniques

  • Fault injection via JTAG debug interfaces
  • Fault control using fault injection using custom HW blocks in a system
  • Use of FPGA platforms for runtime fault emulation in their configuration memory


Physical Fault Injection

  • Radiation testing with heavy ions, protons, or neutrons
  • Electromagnetic interference (EMC) testing
  • Laser fault injection into specific circuit regions
  • Clock and voltage glitch injection

At SolidKosmos, we offer advanced EDA tools and services to support fault-based functional verification, including:

  • SK-RAFT – our cross-platform fault injection tool for various computing systems like FPGAs, processors, GPUs and AI accelerators
  • Radiation characterisation experiments including SEE and TID testing
  • Custom development of FDIR strategies and Fault-tolerant computing architectures

Our solutions are tailored to comply with relevant standards and built to enhance computing systems’ dependability, safety, and robustness across industries.

Qualification of IC components

What is component classification?

Electronic components are categorised based on their intended applications, reliability standards, and environmental tolerances:​

  • Commercial Off-The-Shelf (COTS) Components: These are mass-produced, readily available parts designed for general commercial applications. This category includes consumer-grade, automotive-grade, and defence/military-grade components. While they are cost-effective and benefit from rapid technological advancements, they are not inherently designed for extreme environments like space.​
  • Space-Grade Components: Specifically engineered to operate reliably in the harsh space conditions. They are further divided into:
    • Radiation-Tolerant Components: Similar to automotive and defence components but with enhancements like ceramic packaging and rigorous testing to ensure they can withstand certain levels of radiation.
    • Radiation-Hardened (Rad-Hard) Components: Designed from the ground up for space applications, these components can endure high levels of total ionising dose (TID), are immune to single-event latch-up (SEL), and have very low cross-sections for single-event effects (SEEs).

The adoption of non-space-graded components in space applications offers several advantages:​

  • Cost Efficiency: COTS components are generally less expensive than space-qualified parts, making them attractive for budget-conscious missions.​
  • Advanced Performance: They often incorporate the latest technologies, providing higher performance capabilities.​
  • Availability: Being mass-produced, COTS components are readily available, reducing lead times.​


However, challenges include:​

  • Radiation Susceptibility: COTS components are not inherently designed to withstand the radiation levels encountered in space.​
  • Lack of Space Qualification: They do not undergo the rigorous testing required for space missions, necessitating additional validation.​
  • Reliability Concerns: COTS components may pose reliability risks in the harsh space environment without proper screening.​

At SolidKosmos, we specialise in enabling the reliable deployment of Commercial Off-The-Shelf (COTS) components in space applications. Our products and engineering services support the integration, validation, and qualification of COTS-based systems through a combination of emulated and physical testing and embedded system design.