One of LTspice’s features I have found incredibly useful is it’s ability to process .wav files as a voltage input and the write the voltage output of the circuit to a new audo file.

Audio Settings

When working with audio in LTspice, it is important to ensure the correct audio format and encoding are used. The .wav file is just a container for uncompressed pulse-code modulation (PCM) data. To process audio files in the .wav file format it is important to make sure the file is encoded corectly. The .wav file is a just a container for raw uncompressed pulse-code modulation (PCM) data.

So when importing your audio files into LTspice make sure you take note of the audio encoding, bit rate, sample rate, audio duration and make sure the audio channel is monophonic

Most audio recording software has the option to export wavefiles in 8-bit to 32-bit PCM format. In most cases, 16-bit should suffice.

See Audacity Export Example

---

Download Audacity or Audacity github

Open a new Audacity project and navigate to Tracks > Add New > Mono Track. Click on the newly added track and then navigate to Generate > Pluck to make a guitar plucking sound.

Take note that Audacity uses the MIDI pitch number which is diffrent than the key number when generating the pluck sound.

LTspice Settings and Circuit

Once you have your audio file you want to use, I would recommend moveing it into the root directory where your LTspice project is located. Otherwise, you will have to provide the full path to your audio file.

.
├── pluck.wav
└── project.asc

Add Audio Input

Right click the value of your voltage source and put the folowing in the empty text box.

wavefile=path/to/your_audio.wav

This voltage source will now serve as your audio input in your circuit.

Simulation settings

The next step is going to be to set up a transient analysis equal to the duration of your audio sample.

This can be done by adding the flowing directive by pressing . on your keyboard. You can also use the GUI by naviagiting to Simulate > Configure Analysis and edit your settings in the Transient tab.

In my case my directive looks like the flowing but you may need to change the duration of analysis.

.tran 0 1s 0s 0.1s

Audio Output

The next step is going to be to add the output newtork lable by pressing n on your keyboard. Keep note of the name of this node as it acts as a varable for the output data. In the example image this is V_Out.

See Example Low Pass Filter Schmatic

---

click here if you want to know more about RC filters

Here is a simple low pass filter example with a cut off frequency of $ \approx 10061 $ Hz which is the closest I could get using standard components.

Remember

$$ f_c = {1 \over 2\pi RC} $$

Once you have your circuits input, output, and simulation settings configured we need to use the .wave directive to output your audio file the circuit.

.wave <output.wav> <bit rate> <sample rate> V(<output node>)

Given my audio settings.

.wave pluck_out.wav 16 44100 V(V_Out)

Example Audio

Listen carefully, the original audio should sound sharper than the outputted file. Looking at LTspice output image (right) you can see the attenuation from the right of the red line onward compared to the original audio (left).

Original	LTspice output

In my summer semester of 2025 I decided to take a C programming class to sharpen my coding skills. But, as my assignments became more complex, they required multiple header and implementation files. This is where tools known as build systems come into handy, such as GNU Make. The problem with C build systems is that there are arguably too many of them, and on top of this, there are what are known as meta build systems. Meta build systems are tools that create build scripts for other build systems.

After reviewing the laundry list of compiler tools, I settled on CMake. CMake is a meta build system that can generates makefiles tailored for a specific platform and compiler, allowing you to easily cross-compile for different target architectures.

With all this out of the way lets set up a simple C project with CMake!

CMake has many features that I will not be covering here so you many want to refer to the CMake documentation

Installation

I would recommend following the official CMake installation guide as this may become out of date! On top of this, I have not tested my CMakeLists.txt file on Windows and recommend using Windows Subsystem for Linux (WSL) unless you are devloping applications specificly for Windows.

sudo apt install cmake

cmake --version

winget install cmake

Project Structure

I am not sure if there is a formal name for this type of project structure, but this is what I have seen used out in the wild most often for C and C++ projects and what I prefer to use.

Project Name
├── README
├── LICENCE	
├── CMakeLists.txt    // simple CMakeLists.txt
├── build             // Where your build files go
├── include           // header files
├── lib               // external libraries (.so or .dll)
└── src               // source code 
    └── main.c

Basic CMakeLists

Here is a basic simple CMakeLists.txt to get a C or C++ project started. In your projects root directory copy this into your CMakeLists.txt file.

Make sure to replace anything you see in <> such as <Name> without the brackets.

cmake_minimum_required(VERSION 3.24)
set(PROJECT_NAME <Name>)
project(${PROJECT_NAME})

set(CMAKE_C_STANDARD 23) 
set(CMAKE_C_STANDARD_REQUIRED ON) 

# list of c files to compile
set(SOURCES
  # Source files go here
  # src/main.c
  <add files here>
)

# gcc compile options (Optional)
# add_compile_options(-Wall -Wextra -save-temps)

add_executable(${PROJECT_NAME} ${SOURCES})

target_include_directories(${PROJECT_NAME}
  PRIVATE
        ${PROJECT_SOURCE_DIR}/include
)

Build and Run

Once you have copied and edited your CMakeLists.txt you need to run cmake to generate the lower level build scripts for your project.

In your build directory run:

cmake ..

Running this command will generate a Makefile in your project’s build directory.

Once your build scripts are generated run make in the build directory to compile your project.

make

Doing so will create a compiled binary in your build directory that you run using ./<project-name>