C++ Projects with Source Code

Project Details: A simple two-player command-line Tic-Tac-Toe game written in C++. It features a clear user interface where players take turns choosing grid locations. The game logic checks for winning conditions and displays the winner or a draw at the end of the game.

Features:

• Two-player mode (Player vs Player)
• Interactive board display with row and column inputs
• Win condition checks for rows, columns, and diagonals
• Clear and simple CLI interface for easy interaction
• Handling invalid inputs (occupied positions)

Key Tools & Libraries:

• C++ (Core language)
• Vector for storing game state
• Standard I/O operations for user interaction

Project Source Code: GitHub Gist

Project Details: A simple C++ application to manage tasks efficiently. Users can add, update, delete, and view their tasks. The system uses file handling for data persistence, ensuring that tasks are saved even after the program is closed.

Features:

• Add a new task
• Update an existing task
• Delete a task
• View all tasks
• Data persistence using file handling

Key Tools & Libraries:

• C++ (Core language)
• File handling for data persistence

Project Source Code: GitHub

Project Details: A console-based C++ application designed to manage student records for educational purposes. It allows users to insert, view, search, delete, update, sort, and display statistics of student information. This project demonstrates the fundamentals of C++ programming, such as basic input/output, functions, and file handling.

Features:

• Insert new student records
• View all student records
• Search student record by ID or name
• Delete student records
• Update student information
• Sort students by name
• Display statistics of student records

Key Tools & Libraries:

• C++ (Core language)
• Basic file handling (for record storage)
• Console-based user interface (CLI)

Project Source Code: GitHub

Project Details: A simple yet effective C++ program for managing inventory. It allows users to add, remove, find, update, and view products in the inventory. The system also provides functionality to save and load the inventory data from files, making it useful for small businesses to track their products.

Features:

• Add, remove, find, update, and view products
• Save inventory data to a file
• Load inventory data from a file
• Organized using Object-Oriented Programming (OOP) principles

Key Tools & Libraries:

• C++ (Core language)
• Vector (for managing product data)
• File handling (for saving/loading inventory)

Project Source Code: GitHub

Project Details: A simple console-based password manager written in C++. This application allows users to store and encrypt passwords for various websites using a three-letter key. The manager also supports generating new passwords, decrypting stored ones, and managing user input through a secure menu system.

Features:

• Decrypt existing passwords using a website and key
• Generate and encrypt new passwords with a three-letter key
• Add custom passwords with encryption
• Display all encrypted passwords in alphabetical order
• Delete passwords after verifying admin pin
• Supports password storage in a secure manner
• Currently supports the German language

Key Tools & Libraries:

• C++ (Core language)
• CodeBlocks (IDE)

Project Source Code: GitHub

Project Details: A mini ATM project that implements basic ATM functionalities using Object-Oriented Programming (OOP) concepts in C++. The functionalities include checking account balance, cash withdrawal (with validation), user details verification, and updating the linked mobile number.

Features:

• Check account balance
• Cash withdrawal with input validation (ensures withdrawal amount is less than account balance)
• Display user details for verification
• Update mobile number linked to the bank account

Key Tools & Libraries:

• C++ (Core language)
• Object-Oriented Programming (OOP) concepts

Project Source Code: GitHub

Project Details: A C++-based currency conversion program that allows users to convert currencies using a set of predefined exchange rates stored in JSON format. The program implements basic programming concepts like arrays, loops, functions, and error handling.

Features:

• Currency conversion using predefined exchange rates
• JSON data structure for storing currency rates
• User input with validation via recursive functions
• Console formatting using IO manipulator functions
• Error handling with try/catch blocks
• File handling to store and retrieve exchange rate data

Key Tools & Libraries:

• C++ (Core language)
• JSON (For currency rates)
• IO Manipulators (For formatting output)
• File handling (For storing and accessing exchange rate data)

Project Source Code: GitHub

Project Details: A simple C++ console-based quiz game that asks players multiple-choice questions and calculates their score based on correct answers. The game provides instant feedback after each question and displays the final score at the end.

Features:

• Console-based interface
• Five multiple-choice questions focused on C++ concepts
• Calculation of the player’s final score
• Instant feedback for each question

Key Tools & Libraries:

• C++ (Core language)

Project Source Code: GitHub

Project Details: A simple implementation of the Hangman game in C++ using basic programming concepts such as functions, arrays, loops, and file handling. The game selects a random word from an input file and the user tries to guess the letters to complete the word while avoiding incorrect guesses.

Features:

• Random word selection from an input file (words.txt)
• Score tracking based on correct and incorrect guesses
• Visual representation of the hangman figure for incorrect guesses
• Word completion rewards with additional points
• Saves game score and word to an output file (scores.txt)
• Input validation for file operations and user input

Key Tools & Libraries:

• C++ (Core language)
• File handling for input (words.txt) and output (scores.txt)
• Basic game mechanics using arrays, loops, and functions

Project Source Code: GitHub

Project Details: A simple digital clock created using C++ programming language. The clock displays the current time by incrementing seconds, minutes, and hours, following the standard logic of a 24-hour time format. It runs in an infinite loop and updates the time accordingly.

Features:

• Displays current time in a digital clock format
• Automatically increments seconds, minutes, and hours
• Resets seconds after 60, minutes after 60, and hours after 24
• Simple logic with infinite loop for real-time updating

Key Tools & Libraries:

• C++ (Core language)

Project Source Code: GitHub

Project Details: A simple calendar application developed in C++ that allows users to view any month’s calendar, store events, and retrieve them later. The application is lightweight and designed to work on all modern computer systems. It can also be compiled to run on any operating system, offering a compact, user-friendly agenda for managing dates and events.

Features:

• View any month’s calendar
• Store events related to specific dates
• Load and view stored events
• Small memory footprint, cross-platform compatibility
• Can serve as a quick agenda or date reference tool

Key Tools & Libraries:

• C++ (Core language)
• Makefile (For project build automation)
• Shell (For script execution)

Project Source Code: GitHub

Project Details: A simple voting system built using C++14 that allows users to cast votes and manage voting outcomes. This command-line application demonstrates basic C++ programming principles, including input handling, conditional logic, and basic data storage.

Features:

• Simple voting system
• Allows multiple candidates to be voted on
• Tracks total votes for each candidate
• Outputs the winner based on the highest votes
• Written in C++14

Key Tools & Libraries:

• C++14 (Core language)
• CMake (Build system)

Project Source Code: GitHub

Project Details: A simple C++ implementation of a Stopwatch class using std::chrono::high_precision_clock. The class allows users to measure execution time in nanoseconds, microseconds, milliseconds, and seconds. It also supports lap time functionality, where users can measure time intervals repeatedly with the same stopwatch instance.

Features:

• Easy-to-use stopwatch with time measurement in multiple formats (seconds, milliseconds, microseconds, nanoseconds)
• Lap time functionality for measuring multiple intervals with a single instance
• No external dependencies; a single header file is required
• Fully integrates with std::chrono for high-precision timing
• Includes formatted output for both total elapsed time and individual lap times
• Example usage and code snippets for quick integration into any project

Key Tools & Libraries:

• C++ (Core language)
• std::chrono for high-precision timing

Project Source Code: GitHub

Project Details: A comprehensive command-line banking system that allows account creation, secure login, transaction tracking, and customer service management. It integrates efficient data structures like Binary Search Trees (BST) for account records and queues for customer service. This project is built with modern C++ practices and is aimed at offering a user-friendly experience.

Features:

• Account creation, modification, and deletion
• Secure login system with password masking and hashed credentials
• Transaction handling: deposit, withdrawal, and transfer
• Transaction history tracking using stacks and vectors
• Customer service request queue (FIFO)
• Color-coded CLI interface for enhanced UX
• Modular object-oriented code structure
• Data persistence with CSV files
• Role-based login and menu options for employees and customers

Key Tools & Libraries:

• C++ (Core language)
• WinAPI & conio.h (For Windows-based CLI UI)
• CSV for data persistence
• Binary Search Tree (BST) for storing account records
• Vector, Stack, Queue for managing transaction history and service requests

Project Source Code: GitHub

Project Details: A C++ based contact management system that enables users to manage contact information with functionalities like adding, deleting, modifying, and sorting contacts. The system uses file handling for storing the contact list and provides a simple user interface for interaction.

Features:

• Reading contact list from file
• Searching and modifying contact by field
• Sorting contacts by various fields
• Adding, removing, and printing individual contacts
• Printing the entire contact list
• Saving the updated contact list to file
• Quit program option

Key Tools & Libraries:

• C++ (Core language)
• File handling (For contact storage)
• Data structures for sorting and searching contacts

Project Source Code: GitHub

Project Details: A C++ application that implements Huffman’s algorithm to compress files. It calculates character frequencies and uses a tree structure to encode data efficiently. The utility provides file compression using optimal encoding techniques based on Huffman coding, designed for file size reduction while preserving data integrity.

Features:

• File compression using Huffman coding
• Calculation of character frequencies in the source file
• Efficient data encoding using a binary tree structure
• Supports reading from a source file and writing to a compressed destination file
• Uses priority queues for efficient tree construction
• Object-Oriented Programming (OOP) principles applied for modularity and maintainability

Key Tools & Libraries:

• C++ (Core language)
• fstream (File handling)
• STL containers: vector, priority_queue
• Huffman coding algorithm for data compression

Project Source Code: GitHub

Project Details: A library management system built using C++ that helps manage library records efficiently. The project utilizes object-oriented programming (OOP) principles and file handling to store and manage book information, issue/return records, and fines.

Features:

• Login system for access control
• Add, modify, view, and delete books
• Issue and return books functionality
• Basic fine-charging system for overdue books
• File handling for persistent data storage

Key Tools & Libraries:

• C++11 (Programming Language)
• File handling with fstream for persistent storage
• OOP principles for system design

Project Source Code: GitHub

Project Details: A multi-client chatroom application built using socket programming and multi-threading in C++. It enables multiple clients to connect to a server and communicate in real-time, showcasing fundamental concepts of networking and concurrent programming.

Features:

• Multi-client chat support
• Real-time messaging between clients
• Multi-threaded server handling multiple connections simultaneously
• Mutex lock for thread safety while modifying client list
• Simple CLI-based user interface

Key Tools & Libraries:

• C++ (Core language)
• Socket Programming (For network communication)
• pthread library (For multi-threading)
• Mutex locks (For thread safety in server)

Project Source Code: GitHub

Project Details: A C++ application designed for tracking expenses, supporting both cash-only and cash-and-credit tracking. This project includes a console-based application, as well as an enhanced version with a GUI built using Qt. It focuses on applying object-oriented principles, offering a system to manage and categorize expenses with proper file handling and error checking.

Features:

• Record and categorize expenses with detailed descriptions
• Support for both cash-only and cash-and-credit expenses
• Date-based expense summary (per entry, per day, per month, per year)
• Automatic data saving and loading from CSV files
• Console-based UI with input validation and error checking
• Graphical User Interface (GUI) built with Qt for ease of use
• Object-oriented design with classes like Expenditure, PhPeso, ExpTime, and Description

Key Tools & Libraries:

• C++ (Core language)
• Qt (For GUI development)
• STL Vector (For storing expenses)
• CSV for data persistence
• Makefile for building the project
• QMake (For building the Qt GUI)

Project Source Code: GitHub

Project Details: A C++ implementation of a Maze data structure that uses graphs to solve mazes with four different pathfinding algorithms: Depth First Search, Breadth First Search, Dijkstra, and A*. The project is designed to be memory efficient and adaptable to various maze formats (including file or image input). The structure minimizes the number of vertices needed to store the maze and efficiently computes paths.

Features:

• Four pathfinding algorithms: Depth First Search, Breadth First Search, Dijkstra, A*
• Graph-based maze data structure using vertices and edges
• Memory-efficient vertex creation only where necessary
• Ability to read mazes from various formats (file, image, etc.)
• Animated visual representation of pathfinding algorithms (Windows-based)
• Coordinate path extraction for visualization
• Customizable for different maze formats and algorithms

Key Tools & Libraries:

• C++ (Core language)
• Windows Animation (for visualization)
• Graph-based data structures (Vertex, Edge)
• Pathfinding Algorithms (DFS, BFS, Dijkstra, A*)

Project Source Code: GitHub

Project Details: A simple C++ web scraper that utilizes the curl and libxml2 libraries for fetching and parsing HTML content from web pages. This project demonstrates basic web scraping functionality and is designed to work on Linux systems, with instructions provided for Windows.

Features:

• Web scraping using curl for HTTP requests
• HTML parsing with libxml2 library
• Cross-platform support (Linux-based compilation with instructions for Windows)
• Simple and efficient command-line scraper
• Handles multi-threading with pthreads for improved performance

Key Tools & Libraries:

• C++ (Core language)
• libcurl (For HTTP requests)
• libxml2 (For HTML parsing)
• pthread (For multi-threading)

Project Source Code: GitHub

Project Details: A simple blockchain implementation in C++ that follows basic Bitcoin principles, including peer-to-peer networking, SHA-256 hashing, Merkle Trees, and a basic “mining” process. The system is designed as an in-memory blockchain where blocks can be added, and the network can be updated via HTTP requests. This project provides a hands-on understanding of blockchain basics but is not a complete, production-ready solution.

Features:

• Peer-to-peer network using HTTP requests (replacing WebSockets)
• SHA-256 for hashing headers and blocks
• Merkle trees for efficient data verification
• Basic “mining” process with proof-of-work (simplified)
• In-memory blockchain with data persistence lost on program exit
• Command-line interface to view and add blocks to the blockchain
• Conflict resolution by choosing the longest chain
• Basic validation of blocks (hash, index, and nonce check)

Key Tools & Libraries:

• C++14 (Core language)
• OpenSSL (for SHA-256)
• Simple-Web-Server (for HTTP-based networking)
• JSON library (for serialization)
• Smart pointers (for memory management)

Project Source Code: GitHub

Project Details: A real-time trading application built in C++ that helps users track stock prices and make informed decisions on buying and selling based on specified criteria. The app provides real-time stock data, calculates potential profits or losses, and sends signals to buy or sell when the stock price reaches a predefined limit.

Features:

• Real-time stock price monitoring
• Signal generation for buying and selling stocks based on user-defined criteria
• Cost calculation for stock trades at the moment the signal is generated
• Utilizes external APIs for fetching stock data
• Simple and efficient command-line interface (CLI)
• Customizable for different trading strategies and features
• Prerequisites include curl and JsonCpp libraries for fetching and parsing stock data

Key Tools & Libraries:

• C++ (Core language)
• cURL (For HTTP requests)
• JsonCpp (For parsing JSON data)
• API integration with Twelve Data for real-time stock data

Project Source Code: GitHub

Project Details: A C++ implementation of a peer-to-peer (P2P) file sharing system where peers can share files and download chunks of files from other peers simultaneously. The system includes a server that tracks the files and their chunks and allows clients (peers) to register, share, and download files efficiently using a custom protocol.

Features:

• P2P file sharing with chunk-based distribution
• Registration of shared files and file chunks
• Multi-peer simultaneous download of file chunks
• Server keeps track of available file chunks for peers
• Communication between peers and server via custom protocol
• Command-line interface for managing file sharing and downloading

Key Tools & Libraries:

• C++ (Core language)
• Socket programming (for client-server communication)
• Makefile (for building the project)
• Git (for version control)

Project Source Code: GitHub

Project Details: This project demonstrates how to implement speech recognition in C++ by integrating Rev.ai’s speech-to-text API and Microsoft’s C++Rest SDK. It allows users to convert speech to text by processing audio files and communicating with the Rev.ai API for transcription.

Features:

• Speech-to-text functionality using Rev.ai’s API
• Integration with Microsoft’s C++Rest SDK
• Asynchronous handling of requests for real-time transcription
• Compilation instructions for building the application using g++
• Sample audio files for testing the recognition

Key Tools & Libraries:

• C++ (Core language)
• Rev.ai’s Speech-to-Text API
• C++Rest SDK (for HTTP requests and API interaction)
• Boost (for system and networking support)
• OpenSSL (for secure connections)
• g++ (for compiling the program)

Project Source Code: GitHub

Project Details: A C++ implementation of an Artificial Neural Network. This project demonstrates how to create and train a neural network using custom code. It is designed for educational purposes and provides a basic foundation for neural network operations in C++.

Features:

• Implementation of feedforward and backpropagation algorithms
• C++ code for training and testing neural networks
• Customizable layers and activation functions
• Detailed comments and explanations for learning purposes

Key Tools & Libraries:

• C++ (Core language)
• CMake (For building the project)

Project Source Code: GitHub

Project Details: A simple compiler developed for an undergraduate course in Program Translation. This compiler consists of a frontend that performs lexical analysis and parsing, and a backend for static semantics, code generation, and optimization. It compiles a custom language into assembly code and provides an interpreter to execute the generated assembly.

Features:

• Converts a simple program written in a custom language into assembly code
• Supports basic language constructs such as variables, loops, conditionals, and arithmetic expressions
• Includes a scanner to tokenize input and a parser to generate a parse tree
• Implements static semantics for proper variable declaration
• Generates optimized assembly code by removing redundant instructions
• Provides an interpreter to execute the generated assembly code
• Includes a state transition table for the deterministic finite automaton (DFA)

Key Tools & Libraries:

• C++ (Core language)
• Makefile (for build automation)
• Assembly Language (Generated as output)
• DFA (Deterministic Finite Automaton) for tokenization
• Lexical Analysis & Parsing techniques
• Optimization algorithms for assembly code

Project Source Code: GitHub

Project Details: A collection of computer vision projects implemented in C++ using OpenCV 2.4.2. These projects explore various aspects of computer vision, including image processing, object detection, and real-time video analysis. The projects aim to demonstrate the power of OpenCV in practical computer vision applications.

Projects:

• Color Chain: A program that processes raw image data captured by a CMOS sensor into true RGB color images. The chain includes color interpolation and color correction.
• SIFT Images: Detects keypoints from images and compares two images using SIFT (Scale Invariant Feature Transform) descriptors, useful for object detection and image comparison.
• Real-time Moving Object Detection: Detects, separates, and labels moving objects in video or image sequences captured by a stationary camera, typically used in intelligent video surveillance.
• Automatic License Plate Localization (ANPR) System: Uses Mexican Hat Operators and Euler Number Criteria to localize license plates in complex scenes through stages like grayscaling, edge detection, and segmentation.

Key Tools & Libraries:

• Visual Studio 2010 x86
• OpenCV 2.4.2
• C++ (Core language)

Project Source Code: GitHub

Project Details: A C++ based virtual assistant designed to automate tasks like searching Google, playing music, and managing system operations such as shutdown and restart. It also offers a user-friendly experience with customizable features like voice speed and volume. The assistant can be built and run on both Windows and Linux systems, with features tailored for each operating system.

Features:

• Greet user based on time of day
• Set a personalized name (Linux only)
• Customize voice speed, volume, and pitch (Linux only)
• Play any song
• Directly search Google for any query
• Open direct links to PDFs, songs, and movies
• Shutdown or restart the system directly
• User-friendly commands
• Safe and non-invasive (won’t harm any files in the system)

Key Tools & Libraries:

• C++ (Core language)
• File handling (For storing settings and data)
• Command-line interface for interaction
• Voice customization features (Linux only)

Project Source Code: GitHub

Project Details: This project is a sample Unreal Engine 4.16.2 VR template converted from Blueprint to C++. It was created for users seeking a VR template with C++ implementation. The project supports Oculus Rift and customizes the teleportation mechanic to be more user-friendly. It’s aimed at providing a learning resource for Unreal Engine developers, especially those looking to expand their VR development knowledge.

Features:

• VR template converted from Blueprint to C++
• Teleportation mechanic optimized for Oculus Rift (Robo Recall-style)
• Sample project for Unreal Engine 4.16.2 with VR support
• Template setup for easy integration into Unreal Engine
• Ability to modify the teleportation scheme in Pawn settings

Key Tools & Libraries:

• Unreal Engine 4.16.2 (C++ and Blueprint)
• Oculus Rift (VR hardware)
• MIT License for open-source distribution

Project Source Code: GitHub

Project Details: A simple multiplayer first-person shooter (FPS) built in C++ using RakNet for networking, Raylib for rendering, and a custom networked physics system. The game allows multiple players to connect to a server and play together. Players can move, jump, and fire rockets in a basic FPS environment.

Features:

• Multiplayer support with a server and client system
• RakNet integration for network communication
• Raylib for graphics rendering
• Custom networked physics system
• WASD for player movement, spacebar to jump, left mouse button to fire
• Server-client architecture with support for connecting to remote servers by modifying IP in the source code

Key Tools & Libraries:

• C++ (Core language)
• RakNet (Networking library)
• Raylib (Graphics rendering library)
• Custom Networked Physics System

Project Source Code: GitHub

Project Details: A C++ chess implementation featuring a neural-network-powered AI. It incorporates a versatile UI, multiple AI player types (including a neural network-backed AI), and a training system to improve the AI. The design is inspired by DeepMind’s AlphaZero, but implements a fundamental multi-layer, feed-forward artificial neural network instead of a convolutional neural network (CNN).

Features:

• Fully functional chess gameplay with castling, en passant, and pawn promotion
• AI with multiple algorithms: random move, minimax, alpha-beta pruning, Monte Carlo tree search (MCTS), and neural-network-powered AI
• Training system to improve the neural network AI using backpropagation and dropout algorithms
• UI built with OpenGL, displaying chess pieces and legal moves
• Save and undo functionality for game states
• Keyboard and mouse support for player interaction
• Game state saving for future analysis

Key Tools & Libraries:

• C++ (Core language)
• OpenGL (UI implementation)
• GLFW, GLEW, GSL, GLM, stb (External libraries)
• CMake (Build system)
• Custom neural network and MCTS algorithms for AI

Project Source Code: GitHub

Project Details: This project is a detailed code tutorial aimed at those interested in learning how to create an operating system from scratch. The tutorial progresses through small, manageable lessons that cover the essential concepts of OS development. It starts with low-level concepts and works up to more advanced topics like memory management, file systems, and user mode.

Features:

• Bootstrapping an OS from scratch, without using GRUB
• 32-bit mode and assembly-to-C transitions
• Interrupt handling, screen output, and keyboard input
• Basic libc and memory management
• Filesystem creation and simple shell implementation
• User mode, process scheduling, and potential GUI/networking

Key Tools & Libraries:

• C (Core language)
• Assembly (Low-level operations)
• Makefile (For build automation)
• GitHub repository for managing code and collaboration

Project Source Code: GitHub

Project Details: GALGO is a C++ template library designed to solve optimization problems under constraints. It employs genetic algorithms and utilizes metaprogramming with variadic templates for flexible optimization over multiple parameters. GALGO can handle single and multi-objective optimization tasks, leveraging the power of OpenMP for parallelism, and is implemented using only the Standard Template Library (STL).

Features:

• Genetic algorithm for constrained and unconstrained optimization
• Template-based for flexibility in parameter encoding
• Supports single and multi-objective optimization
• Parallel computation with OpenMP support
• Pre-implemented selection, cross-over, and mutation methods
• Customizable genetic algorithm methods
• No external dependencies, using only the STL

Key Tools & Libraries:

• C++ (Core language)
• OpenMP (Parallel computation support)
• Template metaprogramming
• Standard Template Library (STL) for all data handling
• MIT License

Project Source Code: GitHub

Project Details: A real-time video processing application developed in C++ that visualizes live music performances. The app generates video grids, where each video corresponds to an element in the song, with pre-recorded elements and live-streamed components (from webcams or capture cards). This project integrates OpenGL and FFmpeg for video handling and real-time processing.

Features:

• Real-time video grid generation for live music performances
• Pre-recorded video handling and live-stream video capture
• Webcams and capture cards support for live video streaming
• Built using OpenGL and FFmpeg for video rendering and processing
• Real-time video processing and playback
• Supports webcam capture via AVFoundation on macOS

Key Tools & Libraries:

• C++ (Core language)
• OpenGL (For video rendering)
• FFmpeg (For video decoding and encoding)
• CMake (For building the project)
• pkg-config (For locating shared libraries)
• GLFW (For window management and OpenGL context)
• AVFoundation (For webcam capture on macOS)

Project Source Code: GitHub

Project Details: A C++ implementation of the Crystal Text-to-Speech (TTS) engine, providing a unified framework for multilingual TTS synthesis. It supports SSML (Speech Synthesis Markup Language) for standardization and extensibility, enabling dynamic module loading and multilingual TTS engine support. The system is capable of synthesizing speech in different languages by leveraging distinct algorithms for each language.

Features:

• Unified framework for multilingual TTS synthesis
• Native support of SSML specification for module interfaces
• Dynamic module loading for platform-specific libraries (.dll on Windows, .so on Linux)
• Cross-platform compatibility
• Multilingual TTS engine support
• Automatic module loading based on XML configuration files
• Provides easy-to-implement TTS algorithms through an internal data structure interface
• Works with concatenative and HMM-based TTS engines

Key Tools & Libraries:

• C++ (Core language)
• SSML (Speech Synthesis Markup Language)
• Dynamic loading of modules (.dll, .so)
• XML for configuration files

Project Source Code: GitHub