Software Engineer Intern
•Tacto· 2h
EngineeringInternshipEurope
2h ago
Vinci4D·3 months ago
Vinci combines a foundation model for physics with GPU-native solvers to deliver unprecedented simulation speed and accuracy. There’s no meshing, no approximations, and customer data is not required to train the model: it simply works out of the box. Vinci enables engineers to run thousands of simulations seamlessly, transforming how complex physical systems are designed and optimized.
Our teams rely on high-performance computing environments, secure networking infrastructure, and cloud integrations to accelerate development. We’re looking for a C++-heavy engineer who writes production application code—owning features end-to-end and making them consumable by customers.
This role focuses on shipping application-level C++ systems that are both highly performant and broadly useful. You will implement parsers, simulation/inference pipelines, and distributed execution engines that scale across many CPUs and hosts (from modest clusters up through environments spanning hundreds of CPUs). You’ll balance algorithmic design, systems programming, and pragmatic software engineering to deliver production features—not just micro-optimizations.
Implement and maintain production C++ application code (C++14/17/20) across parsing, simulation, and inference pipelines.
Build robust file parsers and import pipelines for formats such as OAS, GDS, ECXML, STL, STEP, and other domain formats used in hardware/layout tooling.
Design and implement algorithms and data structures for large datasets: streaming parsing, memory-efficient representations, and zero-copy APIs where appropriate.
Improve inference and simulation performance end-to-end: profiling, algorithmic improvements, vectorization, multi-threading, and selective use of accelerators.
Architect and implement distributed execution of simulation/compute workloads that can scale across many CPUs and hosts — job partitioning, scheduling, fault tolerance, and results aggregation — ensuring the work integrates cleanly with application-level APIs.
Integrate native C++ components with higher-level services (Python bindings, gRPC APIs, protobufs) so features are consumable by customers and downstream systems.
Own the full lifecycle of features: design, implementation, testing, CI/CD, packaging, documentation, and production rollout.
Write and maintain unit/integration tests, fuzz tests, and performance benchmarks; use CI to enforce correctness and prevent regressions.
Profile and debug complex issues using tools like perf, gdb, sanitizers (ASan/TSan), valgrind, and CPU/heap profilers; tune memory and CPU usage.
Participate in code and design reviews; mentor junior engineers and promote engineering best practices.
Collaborate with product and customer success teams to ensure features meet customer needs and are easy to consume.
Minimum 5+ years professional software engineering experience, with a strong focus on C++.
Strong production experience in modern C++ (C++14+) including templates, RAII, move semantics, and modern idioms.
Proven experience implementing non-trivial application logic (parsers, algorithms, data structures), not just micro-optimizations.
Deep understanding of Linux internals: processes, threads, scheduling, signals, memory management, and syscalls.
Expertise in concurrency: threads, mutexes, atomics, memory model, condition variables, and designing safe concurrent systems.
Hands-on experience with debugging and profiling tools (perf, gdb, sanitizers, profilers).
Experience working in large-scale codebases: modular design, safe refactors, cross-module interfaces, and collaborative development.
Strong engineering discipline: testing, CI/CD, clear documentation, and reliable release practices.
Excellent communication skills and demonstrated ownership of end-to-end features.
Familiarity with EDA/layout file formats (OAS, GDS, ECXML, etc) and domain XML schemas.
Experience integrating C++ with Python (pybind11, CPython APIs) and exposing gRPC/protobuf APIs.
Experience distributing compute with MPI, task queues, or custom job schedulers; knowledge of Kubernetes, Slurm, or HPC schedulers.
GPU acceleration experience (CUDA/ROCm) or writing GPU-aware C++ code for inference/simulation.
Experience with PostgreSQL or other relational DBs for metadata and operational tooling.
Familiarity with build systems and tooling: CMake, LTO, cross-compilation, and packaging.
Knowledge of binary serialization (protobuf, FlatBuffers), zero-copy techniques, and high-performance I/O (io_uring).
Frontend familiarity (React) for building or collaborating on internal UIs.
Cloud and infra experience (GCP/AWS, Terraform) and operating HPC/GPU clusters.
Engineers who take ownership, ship features that customers can use, and follow through on operational responsibilities.
Pragmatism and systems rigor: shipping maintainable code that meets performance goals.
Curiosity to dive into low-level system behavior and empathy to make features easy for others.
Strong collaboration: clear communication, thoughtful reviews, and mentoring.
Competitive salary, equity, health benefits, flexible time off, and remote-friendly policies. Final compensation depends on experience and location.