English website title...

Audio Reel

Tue, 21 Jul 2026 00:00:00 +0000

This is my Audio Reel !

It compiles the projects I worked on and am the most proud of !

I hope you’ll enjoy it !

Hamstermind

Mon, 16 Feb 2026 00:00:00 +0000

In Hamstermind, you embody an explorer who must solve mysteries and puzzles in a pyramid haunted by an evil pink cat.

The music for Hamstermind was composed by and me. We drew a lot of inspiration from Hollywood film scores, particularly those by John Williams. The goal was to compose music that highlights the pyramid’s mysterious aspect while incorporating the comedic elements of the narrative and characters.

Speaking of the characters, we collaborated remotely with amateur actors for the in-game cutscenes and emotes. I processed some of the voices to give them more character and make them sound more cartoonish.

For the sound design, I recorded the sounds of concrete blocks, tiles, and oyster shells moving to create all the movement sounds in the rooms. I wanted the rocky, grainy texture of the stone blocks to really stand out. For the puzzles, the sounds are more mechanical and detailed; for those, I started with sounds of tools, gears, and so on. The magic of Hamstermind comes from a combination of sounds created with the Vital synthesiser and the sounds of bells and metallic objects ringing.

Sound Design

Wordatro

Mon, 23 Jun 2025 00:00:00 +0000

Wordatro is an easy-to-get-into roguelite word game that challenges both your linguistic and strategic thinking. Build words using a limited pool of letters, with each letter carrying a unique point value. Your goal? Create high-scoring words, trigger powerful combo multipliers, and unlock strategic bonuses to progress through 10 intense levels.

On this project, I composed the soundtrack in a minimal-electro style. I proposed many prototypes with different musical directions to Le Poulet, the developer of Wordatro, and we decided to go with this style. I wanted music that was still upbeat and driving while staying in the background without disturbing the player’s thought process.

For the Sound Design, I recorded many items from chess, board games, and Scrabble tiles. With this material, I created rewarding sounds for the points gained and detailed sounds for all the tiles’ movements.

Sound Design and Audio Integration

Building a Production-Ready REST API with Node.js and Express

Tue, 10 Dec 2024 00:00:00 +0000

Building a REST API seems straightforward until you need to handle authentication, validation, error handling, and documentation. This guide covers best practices for production-ready APIs.

Project Setup

Start with a solid foundation:

mkdir my-api && cd my-api
npm init -y
npm install express dotenv cors helmet compression
npm install -D typescript @types/node @types/express ts-node-dev

Create tsconfig.json:

{
 "compilerOptions": {
 "target": "ES2020",
 "module": "commonjs",
 "lib": ["ES2020"],
 "outDir": "./dist",
 "rootDir": "./src",
 "strict": true,
 "esModuleInterop": true,
 "skipLibCheck": true
 }
}

Folder Structure

Organize your code for maintainability:

src/
├── config/ # Configuration files
├── controllers/ # Route controllers
├── middleware/ # Custom middleware
├── models/ # Database models
├── routes/ # API routes
├── services/ # Business logic
├── utils/ # Helper functions
├── validators/ # Input validation
└── app.ts # App setup

Database Integration

Using Prisma for type-safe database access:

// prisma/schema.prisma
model User {
 id String @id @default(uuid())
 email String @unique
 name String
 password String
 createdAt DateTime @default(now())
 updatedAt DateTime @updatedAt
}

// src/config/database.ts
import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient({
 log: process.env.NODE_ENV === 'development' ? ['query'] : []
})

export default prisma

Authentication & Authorization

Implement JWT-based authentication:

// src/middleware/auth.ts
import jwt from 'jsonwebtoken'
import { Request, Response, NextFunction } from 'express'

interface JWTPayload {
 userId: string
 email: string
}

export const authenticate = async (
 req: Request,
 res: Response,
 next: NextFunction
) => {
 try {
 const token = req.headers.authorization?.split(' ')[1]

 if (!token) {
 return res.status(401).json({ error: 'Authentication required' })
 }

 const payload = jwt.verify(
 token,
 process.env.JWT_SECRET!
 ) as JWTPayload

 req.user = payload
 next()
 } catch (error) {
 res.status(401).json({ error: 'Invalid or expired token' })
 }
}

Error Handling

Centralized error handling:

// src/middleware/errorHandler.ts
import { Request, Response, NextFunction } from 'express'

class AppError extends Error {
 statusCode: number
 isOperational: boolean

 constructor(message: string, statusCode: number) {
 super(message)
 this.statusCode = statusCode
 this.isOperational = true
 Error.captureStackTrace(this, this.constructor)
 }
}

export const errorHandler = (
 err: Error,
 req: Request,
 res: Response,
 next: NextFunction
) => {
 if (err instanceof AppError) {
 return res.status(err.statusCode).json({
 status: 'error',
 message: err.message
 })
 }

 // Log unexpected errors
 console.error('Unexpected error:', err)

 res.status(500).json({
 status: 'error',
 message: 'Internal server error'
 })
}

export { AppError }

Validation

Use Zod for runtime validation:

// src/validators/userValidator.ts
import { z } from 'zod'

export const createUserSchema = z.object({
 body: z.object({
 email: z.string().email('Invalid email address'),
 name: z.string().min(2, 'Name must be at least 2 characters'),
 password: z.string().min(8, 'Password must be at least 8 characters')
 })
})

export const validate = (schema: any) => {
 return async (req: Request, res: Response, next: NextFunction) => {
 try {
 await schema.parseAsync({
 body: req.body,
 query: req.query,
 params: req.params
 })
 next()
 } catch (error) {
 if (error instanceof z.ZodError) {
 return res.status(400).json({
 status: 'error',
 errors: error.errors
 })
 }
 next(error)
 }
 }
}

API Documentation

Auto-generate docs with Swagger:

// src/config/swagger.ts
import swaggerJsdoc from 'swagger-jsdoc'

const options = {
 definition: {
 openapi: '3.0.0',
 info: {
 title: 'My API',
 version: '1.0.0',
 description: 'API documentation'
 },
 servers: [
 {
 url: 'http://localhost:3000',
 description: 'Development server'
 }
 ]
 },
 apis: ['./src/routes/*.ts']
}

export const swaggerSpec = swaggerJsdoc(options)

Document endpoints in route files:

/**
 * @openapi
 * /api/users:
 * post:
 * summary: Create a new user
 * tags: [Users]
 * requestBody:
 * required: true
 * content:
 * application/json:
 * schema:
 * type: object
 * properties:
 * email:
 * type: string
 * name:
 * type: string
 * password:
 * type: string
 * responses:
 * 201:
 * description: User created successfully
 */
router.post('/users', validate(createUserSchema), createUser)

Testing

Write tests with Jest and Supertest:

// tests/users.test.ts
import request from 'supertest'
import app from '../src/app'
import prisma from '../src/config/database'

describe('User API', () => {
 beforeEach(async () => {
 await prisma.user.deleteMany()
 })

 afterAll(async () => {
 await prisma.$disconnect()
 })

 describe('POST /api/users', () => {
 it('should create a new user', async () => {
 const res = await request(app)
 .post('/api/users')
 .send({
 email: 'test@example.com',
 name: 'Test User',
 password: 'password123'
 })
 .expect(201)

 expect(res.body).toHaveProperty('id')
 expect(res.body.email).toBe('test@example.com')
 })

 it('should return 400 for invalid email', async () => {
 const res = await request(app)
 .post('/api/users')
 .send({
 email: 'invalid-email',
 name: 'Test User',
 password: 'password123'
 })
 .expect(400)

 expect(res.body).toHaveProperty('errors')
 })
 })
})

Security Best Practices

Rate Limiting

import rateLimit from 'express-rate-limit'

const limiter = rateLimit({
 windowMs: 15 * 60 * 1000, // 15 minutes
 max: 100 // limit each IP to 100 requests per windowMs
})

app.use('/api/', limiter)

Helmet for security headers

import helmet from 'helmet'
app.use(helmet())

CORS configuration

import cors from 'cors'
app.use(cors({
 origin: process.env.ALLOWED_ORIGINS?.split(','),
 credentials: true
}))

Input Sanitization

import mongoSanitize from 'express-mongo-sanitize'
app.use(mongoSanitize())

Performance Optimization

1. Response Compression

import compression from 'compression'
app.use(compression())

2. Caching

import Redis from 'ioredis'
const redis = new Redis(process.env.REDIS_URL)

async function getCachedData(key: string) {
 const cached = await redis.get(key)
 if (cached) return JSON.parse(cached)

 const data = await fetchFromDatabase()
 await redis.setex(key, 3600, JSON.stringify(data))
 return data
}

3. Database Query Optimization

// Use pagination
const users = await prisma.user.findMany({
 skip: (page - 1) * limit,
 take: limit,
 select: {
 id: true,
 email: true,
 name: true
 // Don't select sensitive fields like password
 }
})

// Use indexes
@@index([email])
@@index([createdAt])

Deployment Checklist

Environment variables configured
Database migrations run
SSL/TLS certificates installed
Rate limiting enabled
Logging configured (Winston, Morgan)
Error tracking (Sentry)
Health check endpoint
API documentation deployed
Load testing completed
Backup strategy implemented

Monitoring

// Health check endpoint
app.get('/health', async (req, res) => {
 try {
 await prisma.$queryRaw`SELECT 1`
 res.status(200).json({ status: 'healthy', timestamp: new Date() })
 } catch (error) {
 res.status(503).json({ status: 'unhealthy', error: error.message })
 }
})

Conclusion

Building production-ready APIs requires attention to:

Structure: Organized code is maintainable code
Security: Authentication, validation, and rate limiting
Errors: Proper error handling and logging
Testing: Comprehensive test coverage
Documentation: Clear API docs for consumers
Performance: Caching and optimization

The complete example code is available on .

Resources

Questions? Leave a comment below or reach out on !

Sans Ligne d'Horizon

Sun, 30 Jun 2024 00:00:00 +0000

For a year, Sacha followed the creation of Les Cent Ciels, a series of one hundred twenty oil pastels by Isabelle Chatelin. Set among fields, beaches, and country roads, this documentary offers an immersive look into the work of the Normandy-based artist.

My process for the soundtrack of Sans Ligne d’Horizon

In the summer of 2024, I had the opportunity to compose the music for this documentary film directed by . Sacha and I decided that the music would illustrate and highlight the film’s painting sequences. My goal with the music was to convey through sound the concentration and focus that , the painter, brings to her canvas. It was important to me that the listener feel both that she is immersed in her painting and that she is outside in a field, on a beach, or on a seaside promenade. I also handled the sound editing for this film after shooting wrapped.

The documentary is divided into four chapters corresponding to the four seasons, with each season having a theme and a musical instrument associated with it.

In spring, we hear the acoustic guitar

In summer, the marimba and vibraphone

In fall, the piano

In winter, electric guitar with a clean sound

Music, Mixing, and Sound Editing

Spaceship Engine

Sun, 30 Jun 2024 00:00:00 +0000

For this project, I created a spaceship prototype in Unreal Engine 5 and then designed the engine sound using Wwise. I also recorded various household appliances (a vacuum cleaner, an electric razor, and a blender) to create the different layers. These layers are triggered based on the ship’s speed.

Sound Design and Audio Integration

Bet'n'Die

Fri, 01 Jul 2022 00:00:00 +0000

Trailer and Walkthrough

During our last year of study, we had to create a video game with a team of 20 students. I worked on an online and arena shooter with Mattéo Siscaro. We composed the music and created the sounds for the game. We had to face many technical challenges related to multiplayer but also to the sound readability of the game.

SMG

Here is how I integrated the SMG sound into the game on Wwise.

Announcer

Advertiser’s integration review in Bet’n’Die

Music, Sound Design and Integration

Blooming Business: Casino

Thu, 30 Jun 2022 00:00:00 +0000

I worked on a management game, Blooming Business Casino. I integrated the sounds of the game in Fmod and also planned the sound integration of the whole game. I also wrote documentation to explain the systems to the programmers.

Sound Design and Audio Integration

Nocturn Chirps

Wed, 30 Jun 2021 00:00:00 +0000

I released a chiptune EP. I made a video to accompany my tracks. I had a lot of fun composing these tracks and experimenting with the limitations of chiptune!

Music

This EP is also available on streaming platforms!

Scarecrow

Wed, 30 Jun 2021 00:00:00 +0000

For this short film, I worked in a team of several Sound Designers with an animation team of half a dozen people. I did a part of the Sound Design for this short film. I mixed the short film on Protools in collaboration with my colleagues.

Sound Design, Mixing and Editing

EdenScape

Fri, 30 Apr 2021 00:00:00 +0000

For this student project, I worked in a duet on sound within a team. I composed and integrated the music of the menus and the first level. I wanted to mix jazz to underline the 50’s atmosphere, as well as orchestral music to accentuate the dramatic side of the plot. I also realized and integrated a part of the sound design.

Music, Sound Design and Integration

Interactive Music - Horror Game

Thu, 15 Oct 2020 00:00:00 +0000

Here is an interactive music system I created on FMOD for a game that would be an infiltration horror game.

Music and Audio Integration

Film Re-Sound Design

Wed, 01 Jan 2020 00:00:00 +0000

Ghost in the Shell

For this Re-Sound Design project, I worked on the opening sequence of the movie Ghost in the Shell. I created an unsettling atmosphere and used vintage analogue and digital sounds for the interfaces and mechanisms; I didn’t want the sounds to sound too modern.

Rogue One

I re-sounded this sequence from the movie Rogue One, emphasising the power of the laser beam.

Sound Design and Music

Video Game Re-Sound Design

Wed, 01 Jan 2020 00:00:00 +0000

Cuphead

In this Re-Sound Design project, I wanted to recreate the cartoonish atmosphere of Cuphead using sounds inspired by early animated films.

Persona 5

The menu design in Persona 5 is unique, so I needed to create dynamic sounds to accompany every movement and transition. I drew inspiration from the objects and elements on screen to design the sounds, using whooshes, playing card sounds, and board game tile sounds that I recorded myself.

Lego Star Wars

Lego Star Wars was one of my favourite games as a kid! I did the sound re-design of the iconic Minikit! I even recorded sounds with my old Legos.

Overwatch

Re-Sound Design of the ultimate ability of Tracer, the character of the game Overwatch.

Zelda: Breath of the Wild

Here, I used Vital to create the sounds for activating the Sheika Tower in Zelda: Breath of the Wild; this allowed me to bring the magic of this ancient technology to life.

Sound Design

Cuphead