Jose Moreno
Embedded Developer
C++
Python
Active 6 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Perception-focused simulation engineer (middle level) specializing in physics-based infrared sensor prototyping. The strongest proven skill is building an end-to-end LWIR radiance pipeline backed by a custom spectral radiance implementation and Unreal integration (thermal_model.cpp plus ThermalCubeActor and RadianceCaptureActor). There is limited evidence of ROS/middleware use, control systems, real-time determinism measurements, automated tests or sim-to-real validation in the public code.
Technical skills
C++• Middle
Python• Middle
AI/ML
NumPy
OpenCV
Computer Vision
Game Dev
Game Dev
Graphics
Robotics
Simulation
Timeline
Technical Staff
•
Lead
C.T engineering
•
Full-Time
environments.
- Implement and maintain subsystem communication, CORBA-based interfaces, module interfaces and lifecycle/state
management.
- Support integration, verification and validation activities, including defect analysis, regression checks and review of test
outcomes.
- Analyze runtime behaviour using Linux tools, logs, traces and GDB to identify interface, state-transition and integration issues.
- Use Git, Bitbucket, CMake, Jenkins, Jira, DOORS and Rational Rose UML in controlled Airbus engineering workflows.
- Contribute to Jira-based tracking of project tasks, defects and delivery status; write technical documentation in English.
C++
Python
CMake
Jira
Confluence
Bitbucket
C
PowerShell
openSUSE
RTOS
Infrared Camera Simulator
Desktop app
Developing a physically based sensor simulator with thermal modelling, projection logic, material/sensor behaviour and synthetic RGB/IR data generation.
C++
U-tad
Master's Degree •
simulation, computer vision and virtual reality
simulation Engineer
•
Middle
Eonsea
•
Internship
Built ROS/Gazebo simulation scenarios and Python tooling for robotic-system testing, sensor integration and validation.
APIS3D Physics Simulation Engine
Desktop app
Developed a modular real-time physics engine with numerical integration, collision detection, update loops and Observer, Factory and
Command patterns.
C++
Universidad Complutense de Madrid
Associate's Degree •
Videogame Development
Software Developer intern
•
Junior
Sener
•
Part-Time
Developed C++ real-time simulation software using component-based architecture and event-driven communication.
- Implemented, tested and debugged deterministic behaviours for simulation and engineering tools.
- Worked with Git, CMake and VS Code in Agile sprints, code reviews, validation and maintainable software workflows.
C++since 2025
Middle AI/ML Engineer
Confidence: High Generalist
Computational geometry and simulation engineer at a middle level with a strength for implementing algorithmic numerical methods and GPU-accelerated particle simulations. The strongest proven skill is algorithmic geometry and numerical solver implementation, evidenced by Poligono.py (ear-clipping triangulation and Jarvis march) and FUMA_LAB/jacobi.py (Jacobi solver and benchmarking). There is no evidence of ML model training, production deployment pipelines, formal unit tests, or experiment tracking in the public code.
Model Architecture & Training
How well models are designed and trained
Not evidenced in public code
Data Pipeline & Feature Engineering
How data is prepared for models
Not evidenced in public code
Experimentation & Evaluation
2/10
How results are measured and tested
Basic experiment-style evaluation and benchmarking are present (timing and numeric error checks) but there is no formal experiment tracking, reproducible runs, or validation suites.
Evidence
fundamentos-matematicos/FUMA_LAB/jacobi.py: main benchmarking loops that measure time and print error for different n values
MLOps & Deployment
How models are shipped to production
Not evidenced in public code
Computational Efficiency
3/10
How efficiently computing resources are used
Clear attention to computational cost and efficiency: memory reporting, a matrix-free cyclic Jacobi variant, and use of Taichi kernels and fields for parallel particle simulation.
Evidence
fundamentos-matematicos/FUMA_LAB/jacobi.py: construir_A prints A.nbytes and jacobi_ciclico implements a matrix-free solver
sistemas-dinamicos-modelos-complejos/lab_simulacion/Ej4.py: Taichi kernels and vectorized fields used to simulate N=1000 particles
Research Depth & Innovation
1/10
Depth of research and new ideas
Implements classical algorithms (ear-clipping triangulation, Jarvis march, Jacobi) correctly but no novel research contributions or reproduced papers.
Evidence
fundamentos-matematicos/ProyectoFinal/Poligono.py: Ear_Clipping, marcha_jarvis and orientacion implementations
fundamentos-matematicos/FUMA_LAB/jacobi.py: multiple Jacobi variants and iterative solver code
Expertise
Generative 3D & Graphics• Middle
Industries
Education• Middle
Software• Middle
Technologies
Python• Middle
OpenCV
Computer Vision
NumPy
Recommendations
- Develop algorithmic geometry and numerical-method modules or libraries (triangulation, convex hull, iterative solvers) for use in graphics or simulation tools.
- Implement and optimize physics-based particle simulations and visual prototypes using Taichi, expanding to GPU backends and parameterized scenarios.
- Package reproducible benchmarks and add unit tests, CI, and simple experiment tracking to validate performance and numerical stability across changes.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Game Developer
Confidence: Medium Engine & Graphics Engineer
Game engine C++ developer (Middle) specializing in engine-side graphics and real-time sensor simulation pipelines. The strongest proven skill is integrating a custom infrared radiance capture/render pipeline into Unreal Engine as shown by RadianceCaptureActor and ThermalCubeActor which manage render targets, dynamic materials and per-primitive radiance data. Public code does not show low-level shader source, widespread performance profiling data, automated tests or a production-ready sensor physics model beyond calls into an external core library.
Gameplay Systems & Mechanics
1/10
How game logic works
Minimal gameplay systems work; code defines Actor classes but contains no decoupled gameplay state machines or non-trivial mechanics.
Graphics & Rendering
6/10
Drawing game visuals
Strong engine rendering integration: custom render target formats, post-process material blendables, dynamic material parameter updates and use of custom primitive data for per-primitive radiance data.
Evidence
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/RadianceCaptureActor.cpp:EnsureRenderTarget (uses RTF_R32f, PF_R32_FLOAT and InitCustomFormat)
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/RadianceCaptureActor.cpp:RefreshCapturePipeline (creates DynamicPostProcessMaterial and uses PostProcessSettings.AddBlendable)
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.cpp:PushThermalDataToPrimitive (SetCustomPrimitiveDataFloat and DynamicDebugMaterial parameter updates)
Physics & Math
3/10
Game physics and math
Some domain math and physics awareness is present but core numerical algorithms are delegated to an external irsim::core library; uses Beer-Lambert attenuation and distance-based computations.
Evidence
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.cpp:GetCurrentSensorRadiance (calls irsim::core::ComputeAtmosphericTransmittance and ComputeSensorBandRadiance)
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.cpp:GetCurrentEmittedRadiance (calls irsim::core::ComputeBandRadiance)
Engine Proficiency
6/10
Skill with the game engine
Clear Unreal Engine C++ proficiency: custom Actor components, constructor helpers, dynamic materials, SceneCaptureComponent2D usage and lifecycle handling including creation and cleanup of runtime objects.
Evidence
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.h:UCLASS and CreateDefaultSubobject usage
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/RadianceCaptureActor.cpp:SyncToPlayerCamera and UpdatePlayerCameraView (FindPlayerCameraComponent and PostProcessSettings management)
JoseMorenob/thermalSimulationUnreal/Plugins/IRSimPlugin/Source/IRSimPlugin/Public/IRSimPlugin.h (plugin module present)
Performance & Frame Budget
4/10
Keeping the game smooth
Evidence of frame-budget awareness and some optimizations such as optional single-channel render target formats, toggling capture-on-movement and avoiding unnecessary per-frame ticks, but lacks profiler captures or zero-alloc hot-path measures.
Evidence
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/RadianceCaptureActor.cpp:EnsureRenderTarget (switch between RTF_R32f and RTF_RGBA16f)
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.cpp:PrimaryActorTick.bCanEverTick = false and conditional updates to DynamicDebugMaterial
Content Pipeline & Tooling
2/10
Tools for game content
Small tooling and pipeline artifacts exist such as a plugin module and build targets but there is limited automation or CI/pipeline code visible.
Expertise
Game Development Tools & Pipeline• Middle
Gameplay & Mechanics Development• Junior
Industries
Gaming• Middle
Technologies
Game Dev
Graphics
C++• Middle
Unreal Engine• mentioned only
Recommendations
- Implement additional authored shader or material HLSL code and include a small shader module to demonstrate end-to-end rendering work and cost trade-offs.
- Add micro-benchmarks or profiler captures and document frame-time impact of single-channel vs RGBA render targets to strengthen performance evidence.
- Expand the plugin with editor tools or Blueprints utilities (import inspectors, capture presets, or editor preview windows) to show designer-facing tooling and pipeline skills.
- Encapsulate and test the numerical core or provide unit tests / reference outputs for the irsim::core calls to demonstrate ownership of simulation code.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Robotics Engineer
Confidence: Medium Perception Engineer
Perception-focused simulation engineer (middle level) specializing in physics-based infrared sensor prototyping. The strongest proven skill is building an end-to-end LWIR radiance pipeline backed by a custom spectral radiance implementation and Unreal integration (thermal_model.cpp plus ThermalCubeActor and RadianceCaptureActor). There is limited evidence of ROS/middleware use, control systems, real-time determinism measurements, automated tests or sim-to-real validation in the public code.
Motion Control & Kinematics
Controlling robot movement
Not evidenced in public code
Perception & Sensor Fusion
5/10
Understanding sensor data
Clear, custom thermal-perception work: a physics-based spectral radiance model and numerical integration are implemented and integrated into an Unreal rendering capture pipeline to produce synthetic LWIR frames.
Evidence
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/thermal_model.cpp:compute_planck_spectral_radiance and integrate_band_radiance
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.cpp:PushThermalDataToPrimitive
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/RadianceCaptureActor.cpp:EnsureRenderTarget and RefreshCapturePipeline
ROS & Middleware
Robot software framework skills
Not evidenced in public code
Control Algorithms
Algorithms that steer robots
Not evidenced in public code
Real-time Systems
1/10
Precise real-time control
Minimal real-time-related artifacts exist (game-tick driven capture and per-frame render-target management) but there are no latency/jitter measurements, real-time executors, or real-time-safe code paths documented.
Simulation & HIL Testing
4/10
Testing robots in simulation
Simulation-focused artifacts and a usable prototype pipeline for LWIR rendering exist (actor classes, dynamic materials, render targets, and a thermal model), but there is no CI HIL testing, rosbag-driven regression tests or explicit sim-to-real validation documented in code.
Evidence
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/ThermalCubeActor.cpp (dynamic material parameter propagation and custom primitive data)
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/RadianceCaptureActor.cpp (scene capture and render target lifecycle)
JoseMorenob/thermalSimulationUnreal/Source/IRSimClean/thermal_model.cpp (physics-based radiance computations)
Verified artifacts
Expertise
Computer Vision & Perception• Middle
Simulation & Digital Twins• Middle
Technologies
Simulation
Recommendations
- Develop physics-based sensor models and visualization tools for research prototypes, focusing on LWIR and other spectral bands using Unreal Engine.
- Integrate the thermal model into simulation test harnesses (rosbags or headless sim) and add regression tests to validate numerical stability and sim-to-real fidelity.
- Extend the work to middleware integration (ROS/ROS2) and provide message interfaces so the sensor output can be consumed by perception and autonomy stacks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: