A comprehensive, production-ready C++ development template designed for rapid project initialization with modern tooling, cross-platform support, and automated workflows. This template provides everything needed to start developing native and cross-platform C++ applications efficiently and cleanly.
Expert Assessment: "This C++ template achieves production-grade quality with exceptional CMake organization, comprehensive tooling integration, and modern development practices. The automated workflows, cross-platform support, and developer experience represent industry best practices." - GitHub Copilot (2025)
- Multi-platform CI/CD: Full GitHub Actions integration for Linux, macOS, Windows
- Code Coverage: Comprehensive gcovr integration with HTML/XML reports
- WebAssembly Support: Complete Emscripten integration with live demos
- Development Tools: clang-tidy, clang-format, cmake-format automation
- VSCode Integration: Extensive keyboard shortcuts and task automation
- Cross-Toolchain Management: Seamless integration with popular C++ toolchains
- Container Support: Complete Docker environment with multi-stage builds
- Coverage Analysis: Only available for native builds (
defaultarchitecture) - Help System: SolutionController.py help documentation planned but not yet started
- Enhanced container development workflows
- Performance profiling integration
- Creation of Conan Package from the project
- 🚀 Overview
- ✨ Key Features
- ⚡ Quick Start
- 🛠️ Prerequisites & Dependencies
- 🏗️ Project Structure
- 🔧 Build System
- 📦 Package Management
- 🧰 Development Tools
- 💻 IDE Integration
- 🌍 Cross-Platform Development
- 🌐 WebAssembly & Emscripten
- 🧪 Testing Framework
- 📚 Library Development
- 🔄 CI/CD Pipeline
- 🛠️ Maintenance & Utilities
- 📖 Documentation
- 📄 License
DotNameCpp is more than just a project template—it's a complete development ecosystem that streamlines C++ development from conception to deployment. Designed with modern C++ best practices, it provides a robust foundation for both library and standalone application development.
This template has been crafted to eliminate the initial setup overhead that typically accompanies C++ projects, allowing developers to focus on writing code rather than configuring build systems and toolchains.
- Zero-Configuration Start: Get productive immediately with sensible defaults
- Scalability: Grows from simple prototypes to complex multi-platform applications
- Developer Experience: Prioritizes ease of use without sacrificing power
- Modern Standards: Embraces C++20/23 features and contemporary tooling
- Production Ready: Includes all necessary components for professional development
- CMake 3.31+ with modern preset system
- Conan 2.0 integration for dependency management
- Ninja build system for fast compilation
- ccache support for accelerated rebuilds
- Cross-compilation ready with toolchain support
- Native Development: Linux, macOS, Windows
- WebAssembly: Emscripten integration for web deployment
- Cross-Compilation: ARM, x86, x64 architectures
- Container Support: Docker and GitHub Codespaces ready
- Static Analysis: clang-tidy with comprehensive rule sets
- Code Formatting: clang-format and cmake-format
- Documentation: Doxygen with automated generation
- Testing: Google Test framework integration
- Debugging: GDB/LLDB support with VSCode integration
- Debugging: CMake files support with VSCode integration
- Dual Structure: Library and standalone application support
- Modular Architecture: Reusable components and utilities
- Asset Management: Integrated resource handling system
- Licensing: Built-in license collection and management
- GitHub Actions: Multi-platform CI/CD pipelines
- Automated Testing: Unit tests, integration tests, and benchmarks
- Release Management: Automated packaging and distribution
- Quality Gates: Static analysis and code coverage integration
git clone git@github.com:tomasmark79/DotNameCpp.gitadd this function to your .bashrc or .zshrc:
clonedotname() {
local PN="${1:-AppName}"
git clone git@github.com:tomasmark79/DotNameCpp.git "$PN" && rm -rf "$PN/.git" && cd "$PN"
python SolutionRenamer.py DotNameLib "$PN"Lib DotNameStandalone "$PN"Standalone
}Then simply use:
clonedotname # Clone with default name "AppName"
clonedotname MyCustomAppName # Clone with custom name# Use the Python controller for advanced options - callable from VSCode tasks
python SolutionController.py standalone "🗡️ Conan install" default Debug
python SolutionController.py standalone "🔧 CMake configure" default Debug
python SolutionController.py standalone "🔨 Build" default Debugpip install conan
conan profile detect
# Use the Python controller for advanced options - callable from VSCode tasks
python SolutionController.py standalone "🗡️ Conan install" default Debug
python SolutionController.py standalone "🔧 CMake configure" default Debug
python SolutionController.py standalone "🔨 Build" default DebugClick the Code button on GitHub → Codespaces → Create codespace for instant cloud development environment.
# Zero to Hero: Complete setup, build, test, and package
python SolutionController.py both "🦸 Zero to Hero" default Debug| Tool | Minimum Version | Purpose | Installation |
|---|---|---|---|
| Git | 2.25+ | Version control | Download |
| CMake | 3.31+ | Build system | Download |
| Conan | 2.0+ | Package manager | pip install conan |
| Python | 3.8+ | Automation scripts | Download |
| Ninja | 1.10+ | Build tool | Download |
| Tool | Purpose | Installation |
|---|---|---|
| ccache | Compilation cache | Download |
| clang-tidy | Static analysis | Part of LLVM |
| clang-format | Code formatting | Part of LLVM |
| cmake-format | CMake formatting | pip install cmake-format |
| Doxygen | Documentation | Download |
| gcovr | Code coverage | pip install gcovr |
| Platform | Compilers | Versions |
|---|---|---|
| Linux | GCC, Clang | GCC 11+, Clang 14+ |
| macOS | Clang, GCC | Xcode 14+, GCC 11+ |
| Windows | MSVC, Clang, GCC | VS 2022, Clang 14+, MinGW 11+ |
| Emscripten | emcc | 3.1.0+ |
📁 DotNameCpp/
├── 📁 .github/ # GitHub configuration files
├── 📁 .vscode/ # Visual Studio Code configuration
├── 📁 assets/ # Project resources
│ ├── customstrings.json # Localization strings
│ ├── DotNameCppLogo.svg # Project logo
│ └── ems-mini.html # Emscripten template
├── 📁 build/ # Build outputs (auto-generated)
│ ├── 📁 installation/ # Installation artifacts
│ ├── 📁 standalone/ # Standalone builds
│ └── 📁 tarballs/ # Distribution packages
├── 📁 cmake/ # CMake modules and utilities
│ ├── project-common.cmake # Common project settings
│ ├── project-library.cmake # Library-specific configuration
│ ├── project-standalone.cmake # Standalone app configuration
│ ├── tmplt-*.cmake # Feature modules (sanitizers, hardening, etc.)
│ └── 📁 modules/ # Custom CMake modules
├── 📁 conan_tools/ # Conan integration utilities
├── 📁 doc/ # Documentation (auto-generated)
├── 📁 include/DotNameLib/ # Public library headers
├── 📁 src/ # Library source code
│ ├── DotNameLib.cpp # Main library implementation
│ ├── 📁 Assets/ # Asset management utilities
│ ├── 📁 Logger/ # Logging functionality
│ └── 📁 Utils/ # Utility classes
├── 📁 standalone/ # Standalone application
│ ├── 📁 src/ # Application source
│ └── 📁 tests/ # Application tests
├── 📄 CMakeLists.txt # Root CMake configuration
├── 📄 CMakeUserPresets.json # CMake presets for different configurations
├── 📄 conanfile.py # Conan dependency specification
├── 📄 SolutionController.py # Main Template automation script
├── 📄 SolutionRenamer.py # Template renaming utility
└── 📄 SolutionUpgrader.py # Template update utility
assets/: Static resources, configurations, and branding materialscmake/: Modular CMake configuration with reusable templatesinclude/: Public API headers for library consumerssrc/: Library implementation with organized subsystemsstandalone/: Example application demonstrating library usageconan_tools/: Custom Conan integration and utility functions
The project uses CMake presets for consistent, reproducible builds across different environments:
# List available presets
cmake --list-presets
# Configure with a preset
cmake --preset debug-linux-x86_64-gcc-15
# Build with a preset
cmake --build --preset debug-linux-x86_64-gcc-15Depends on your toolchain configuration. Every new build configuration should be added to the CMakeUserPresets.json file.
Configure your build with these CMake options:
# Core options
option(BUILD_LIBRARY "Build the DotNameLib library" ON)
option(BUILD_STANDALONE "Build the standalone application" ON)
option(BUILD_TESTS "Build unit tests" OFF)
option(BUILD_DOCS "Generate documentation" OFF)
# Feature options
option(ENABLE_HARDENING "Enable security hardening" OFF)
option(ENABLE_SANITIZERS "Enable runtime sanitizers" OFF)
option(ENABLE_IPO "Enable interprocedural optimization" OFF)
option(ENABLE_CCACHE "Use ccache for compilation" ON)
option(ENABLE_COVERAGE "Enable code coverage analysis" OFF)
# Platform-specific options
option(EMSCRIPTEN_BUILD "Build for Emscripten/WebAssembly" OFF)
⚠️ Important Coverage Note: Code coverage analysis is exclusively supported for native builds using thedefaultarchitecture. Cross-compilation targets (Emscripten, MinGW, ARM, etc.) cannot execute tests locally, therefore coverage data collection is not possible for these platforms. Always use native builds when coverage analysis is required.
# Complete workflow: clean → configure → build → test → package
python SolutionController.py both "🦸 Zero to Hero" default Debug
# Quick rebuild default Debug
python SolutionController.py both "🔨 Build" default Debug
# Clean build for default Debug
python SolutionController.py both "🧹 Clean selected folder" default Debug
# Build with code coverage enabled
cmake --preset debug-linux-x86_64-gcc-15 -DENABLE_COVERAGE=ON
cmake --build --preset debug-linux-x86_64-gcc-15
ctest --preset debug-linux-x86_64-gcc-15
make coverage
# Coverage workflow with SolutionController
python SolutionController.py standalone "📊 Configure with Coverage" default Debug
python SolutionController.py standalone "🔨 Build" default Debug
python SolutionController.py standalone "🧪 Run CTest" default Debug
python SolutionController.py standalone "📊 Coverage HTML Report" default Debug
# Cross-compilation example
python SolutionController.py standalone "🔨 Build" x86_64_linux-clang20 Release This template uses Conan 2.0 for modern, efficient dependency management:
# conanfile.py excerpt
def requirements(self):
# Core dependencies
self.requires("fmt/10.1.1")# Install dependencies
conan install . --build=missing
# Create dependency graph
conan graph info . --format=html > dependencies.html
# Update dependencies
conan install . --update
# Create lockfile for reproducible builds
conan lock create .Create optimized profiles for different scenarios:
# profiles/development
[settings]
os=Linux
arch=x86_64
compiler=gcc
compiler.version=13
compiler.libcxx=libstdc++11
build_type=Debug
[options]
*:shared=False
*:fPIC=True
[buildenv]
CC=gcc-13
CXX=g++-13For clang-tidy linting must exist build artifacts due to the nature of the analysis.
Comprehensive static analysis is integrated into the build system:
# Run static analysis
python SolutionController.py both "🔍 clang-tidy linting" default Debug
# Custom clang-tidy configuration
python SolutionController.py standalone "🔍 clang-tidy linting" default DebugConfiguration in .clang-tidy:
Checks: >
clang-diagnostic-*,
clang-analyzer-*,
cppcoreguidelines-*,
modernize-*,
performance-*,
readability-*,
bugprone-*,
cert-*,
misc-*
WarningsAsErrors: ''
CheckOptions:
- key: readability-identifier-naming.VariableCase
value: camelCase
- key: readability-identifier-naming.FunctionCase
value: camelCase
- key: readability-identifier-naming.ClassCase
value: PascalCaseConsistent code style across the project:
# Format all C++ code
python SolutionController.py both "📐 clang-format" noNeedArch
# Format CMake files
python SolutionController.py both "📏 cmake-format" noNeedArchThis template provides deep VSCode integration with optimized settings and tasks.
| Shortcut | Action | Description |
|---|---|---|
| F5 | Quick Debug | Start debugging standalone application |
| F7 | Quick Build | Build standalone application |
| Shift+F7 | Build Menu | Show comprehensive build options |
| Ctrl+F7 | Other Tasks | Show utility and maintenance tasks |
| Ctrl+Alt+F | Format Code | Run clang-format on current file |
| Ctrl+Alt+L | Lint Code | Run clang-tidy analysis |
| Ctrl+Alt+M | Format CMake | Run cmake-format on CMake files |
| Ctrl+Alt+P | Build All Presets | Build all CMake presets |
| Ctrl+Alt+R | Run Standalone | Execute standalone binary |
| Ctrl+Alt+E | Launch Emscripten | Build and serve Emscripten version |
| Ctrl+Alt+Shift+C | Configure with Coverage | Configure build with coverage enabled |
| Ctrl+Alt+Shift+H | Coverage HTML Report | Generate and open HTML coverage report |
| Ctrl+Alt+Shift+F | Coverage Full Report | Generate both HTML and XML coverage reports |
| Ctrl+Alt+Shift+T | Coverage Tasks | Show coverage task menu |
| Ctrl+Alt+Shift+O | Coverage Tasks (Other) | Quick access to coverage tasks (native build only) |
🔨 Building Tasks (Shift+F7):
- 🚀 Zero to Build: Complete clean build workflow
- 🦸 Zero to Hero: Full development cycle with testing and packaging
- 🧹 Clean Build: Remove build artifacts and rebuild
- 🗡️ Conan Install: Install and update dependencies
- 🔧 CMake Configure: Configure build system
- 📊 CMake configure with Coverage: Configure build with code coverage enabled
- 🪲 CMake Configure with CMake-debugger: Configure with CMake debugger
- 🔨 Build: Compile the project
- 🧪 Run Tests: Execute test suite
- 📜 Gather dependency licenses: Gather dependency licenses
- 📌 Install built components: Install built components
- 🗜️ Create Tarballs for distribution: Package for distribution
- 🛸 Run CPack: Create installation packages
🛠️ Other Tasks (Ctrl+F7):
- 📖 Generate Documentation: Create Doxygen documentation
- 📐 Format Code: Apply code formatting
- 📏 Format CMake: Format CMake files
- ⚔️ Create Conan Recipe: Generate Conan package
- 📊 Dependency Graph: Visualize project dependencies
- 🔍 Security Scan: Run security analysis
- 🧪 Benchmark: Run performance tests
🔬 Coverage Tasks from Other Menu:
- 📊 Coverage HTML Report: Quick HTML report (native build only)
- 📊 Coverage XML Report: Quick XML report (native build only)
- 📊 Coverage Summary: Quick summary display (native build only)
- 📊 Coverage Full Report: Quick full report (native build only)
- 📊 Coverage Reset: Quick coverage reset (native build only)
Optimized C++ IntelliSense settings in .vscode/c_cpp_properties.json:
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"/home/tomas/.cache/CPM/cxxopts/**",
"/home/tomas/.cache/CPM/fmt*/**",
"/home/tomas/.conan2/p/b/imgui*/**",
"/home/tomas/.conan2/p/glm*/**",
"/home/tomas/.conan2/p/nlohm*/**"
],
"defines": [],
"compilerPath": "${default}",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "${default}",
"recursiveIncludes": {
"reduce": "always",
"priority": "beforeSystemIncludes",
"order": "breadthFirst"
}
}
],
"version": 4
}| Feature | Linux | macOS | Windows | WebAssembly |
|---|---|---|---|---|
| Native Build | ✅ | ✅ | ✅ | N/A |
| Cross-Compilation | ✅ | ✅ | ✅ | ✅ |
| Package Management | ✅ | ✅ | ✅ | ✅ |
| IDE Integration | ✅ | ✅ | ✅ | ✅ |
| CI/CD | ✅ | ✅ | ✅ | ✅ |
| Container Support | ✅ | ✅ | ✅ | ✅ |
# ARM64 Linux from x86_64
conan install . -pr:h=profiles/arm64-linux -pr:b=default
# Windows from Linux
conan install . -pr:h=profiles/windows-x64 -pr:b=default
# Configure cross-compilation
cmake --preset cross-arm64-releaseStatus: ✅ Implemented
Complete Docker environment with multi-stage builds:
# Quick start from project root
./docker.sh dev # Start development environment
./docker.sh test # Run zero-to-hero build test
./docker.sh prod # Start production web server
# Or navigate to docker directory for full control
cd docker/
make help # Show all available commands
make dev && make shellKey Features:
- Organized structure: All Docker files in
/dockerdirectory - Multi-stage builds: Development, production, and clean environments
- Easy access: Quick commands via
./docker.shorcd docker && make - Persistent volumes: Conan cache and ccache for faster rebuilds
- Pre-configured aliases:
build-debug,test-run,zero-to-hero - Web hosting: Nginx server for documentation and demos
- Live development: Source code mounted for real-time changes
See docker/README.md for complete usage guide.
This template provides seamless WebAssembly development with Emscripten:
# Build for web deployment
python SolutionController.py both "🚀 Launch Emscripten Server" noNeedArch
# Quick Emscripten build
cmake --preset debug-emscripten-wasm-clang-20
cmake --build --preset debug-emscripten-wasm-clang-20- Asset Preloading: Automatic asset packaging for web deployment
- Modern Web Standards: ES6+ JavaScript integration
- Responsive Design: Mobile-friendly web interface
- Performance Optimization: WebAssembly-optimized builds
Experience the template in action:
- Debug Version: DotNameStandalone.html (Debug)
- Release Version: DotNameStandalone.html (Release)
Experience with more complex scenarios: GPU required
- Debug Version: DotNameStandalone.html (Debug)
- Release Version: DotNameStandalone.html (Release)
# cmake/tmplt-emscripten.cmake excerpt
if(EMSCRIPTEN)
set_target_properties(${target} PROPERTIES
SUFFIX ".html"
LINK_FLAGS "
--preload-file ${CMAKE_SOURCE_DIR}/assets@assets
-s USE_SDL=2
-s ALLOW_MEMORY_GROWTH=1
-s EXPORTED_FUNCTIONS=['_main']
-s EXPORTED_RUNTIME_METHODS=['ccall']
"
)
endif()# Serve locally for development
python -m http.server 8000 -d build/emscripten/debug
# Production deployment (planned)
# python SolutionController.py emscripten "🚀 Deploy Web" noNeedArch
# Current: Manual deployment to web server
# Copy build/emscripten/release/* to your web hosting serviceComprehensive testing framework with Google Test:
// Example test in standalone/tests/
#include <gtest/gtest.h>
#include "DotNameLib/DotNameLib.hpp"
class DotNameLibTest : public ::testing::Test {
protected:
void SetUp() override {
// Test setup
}
};
TEST_F(DotNameLibTest, BasicFunctionality) {
EXPECT_TRUE(DotNameLib::isInitialized());
EXPECT_EQ(DotNameLib::getVersion(), "1.0.0");
}# Run all tests
python SolutionController.py both "🧪 Run CTest" default Debug
# Unit tests only
ctest --preset debug-linux-x86_64-gcc-15 --label-regex "unit"
# Integration tests
ctest --preset debug-linux-x86_64-gcc-15 --label-regex "integration"
# Performance benchmarks
ctest --preset debug-linux-x86_64-gcc-15 --label-regex "benchmark"# Enable coverage during configuration
cmake --preset debug-linux-x86_64-gcc-15 -DENABLE_COVERAGE=ON
# Build with coverage
cmake --build --preset debug-linux-x86_64-gcc-15
# Run tests to generate coverage data
ctest --preset debug-linux-x86_64-gcc-15
# Generate HTML coverage report
make coverage-html
# or using cmake
cmake --build . --target coverage-html
# Generate XML coverage report (for CI/CD)
make coverage-xml
# or using cmake
cmake --build . --target coverage-xml
# Generate both HTML and XML reports
make coverage
# or using cmake
cmake --build . --target coverage
# Display coverage summary in console
make coverage-summary
# or using cmake
cmake --build . --target coverage-summary
# Reset coverage counters
make coverage-reset
# or using cmake
cmake --build . --target coverage-reset
# Alternative: Direct gcovr usage
gcovr --html --html-details -o coverage.html
gcovr -x -o coverage.xmlThe template supports both header-only and compiled library development:
// include/DotNameLib/DotNameLib.hpp
#pragma once
namespace DotNameLib {
// Public API
bool initialize();
void shutdown();
std::string getVersion();
}
// src/DotNameLib.cpp
#include "DotNameLib/DotNameLib.hpp"
namespace DotNameLib {
bool initialize() {
// Implementation
return true;
}
}- You create your own project called Wheels using DotNameCpp and push it to GitHub.
- Then, in your next project named Car, you use the Wheels library as follows:
# in project Car in file project-standalone.cmake
CPMAddPackage("gh:tomasmark79/Wheels#main")
target_link_libraries(${STANDALONE_NAME} PRIVATE WheelsLib CarLib cxxopts::cxxopts)
# in project Car in file project-tests.cmake
target_link_libraries(${TEST_NAME} PRIVATE GTest::gtest GTest::gtest_main WheelsLib dotname::${TEST_NAME_LOWER}_standalone_common)// in project Car in file AppCore.hpp
#include <WheelsLib/WheelsLib.hpp>
std::unique_ptr<dotname::WheelsLib> uniqueWheelsLib;
uniqueWheelsLib = std::make_unique<dotname::WheelsLib> (AppContext::assetsPath);
LOG_I_STREAM << "Wheels count: " << uniqueWheelsLib->getWheelsCount() << std::endl;$ ./CarStandalone
# output
Starting CarStandalone ...
WheelsLib v.0.0.1 constructed ...
Assets: "tmp/Car/build/standalone/default/share/CarStandalone/assets"
path: "tmp/Car/build/standalone/default/share/CarStandalone/assets/DotNameLogoV2.svg"
CarLib v.0.0.1 constructed ...
Assets: "tmp/Car/build/standalone/default/share/CarStandalone/assets"
path: "tmp/Car/build/standalone/default/share/CarStandalone/assets/DotNameLogoV2.svg"
Wheels count: 4
CarLib v.0.0.1 ... destructed
This is a demo error message
Sucessfully exited CarStandalone
WheelsLib v.0.0.1 ... destructedinclude(FetchContent)
FetchContent_Declare(
Wheels
GIT_REPOSITORY https://github.com/tomasmark79/Wheels.git
GIT_TAG v1.0.0
)
FetchContent_MakeAvailable(Wheels)
target_link_libraries(your_target Wheels::Wheels)# Create Conan package
python SolutionController.py both "⚔️ Create conan library recipe" noNeedArch
# In consumer project's conanfile.py
def requirements(self):
self.requires("dotnamelib/1.0.0")add_subdirectory(path/to/Wheels)
target_link_libraries(your_target Wheels::Wheels)find_package(Wheels REQUIRED)
target_link_libraries(your_target Wheels::Wheels)- Namespace Everything: Use project-specific namespaces
- RAII Pattern: Prefer automatic resource management
- Exception Safety: Provide strong exception safety guarantees
- ABI Stability: Consider ABI compatibility for library updates
- Documentation: Comprehensive Doxygen documentation
The main versioning for libraries is maintained in the project definition file at cmake/project-library.cmake.
# Semantic versioning
set(PROJECT_VERSION_MAJOR 1)
set(PROJECT_VERSION_MINOR 0)
set(PROJECT_VERSION_PATCH 0)
set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")Comprehensive CI/CD with multi-platform support:
Implemented Workflows:
- ✅ Linux CI: Ubuntu with GCC and Clang
- ✅ macOS CI: Latest macOS with Xcode
- ✅ Windows CI: Windows Server with MSVC
- ✅ Cross-Platform Testing: Automated test execution
- ✅ Code Quality: Static analysis and formatting checks
- ✅ Documentation: Automated Doxygen generation
- ✅ Public Repository Sync: Automated synchronization to public repo with
-Pubsuffix
Workflow Features:
- Matrix builds across multiple compilers and configurations
- Conan dependency caching for faster builds
- Artifact collection for build outputs
- Code coverage reporting integration
- Release automation with semantic versioning
- Selective file synchronization to public repository
The template includes automated public repository synchronization via make-pub.yml:
- Disabled by default: Requires explicit developer activation
- Enable sync: Set
ENABLE_SYNC=truein.github/workflows/make-pub.conf - Auto-sync: Triggers on push to main branch (when enabled)
- Selective files: Configure via
.github/workflows/make-pub.conf - Repository naming: Creates
[ProjectName]-Pubautomatically - Token support: Uses (PAT)
PUB_REPO_TOKENfor authentication
Badge Status: See repository badges at the top of this README for current build status.
Rename your project from the template:
python SolutionRenamer.py DotNameLib MyAwesomeLib DotNameStandalone MyAwesomeApp
python SolutionRenamer.py MyAwesomeLib DotNameLib MyAwesomeApp DotNameStandaloneAffected files:
- ✓ All CMake configuration files
- ✓ All C++ source files and headers
- ✓ VS Code configuration (
launch.json,tasks.json) - ✓ Documentation (
Doxyfile,README.md) - ✓ Package management (
conanfile.py) - ✓ Web assets (
ems-mini.html) - ✓ Logger configuration
- ✓ License files
Update template files from the upstream repository:
python SolutionUpgrader.pyCentral automation hub for all build and development tasks:
# Interactive usage - Use VSCode tasks for full functionality
python SolutionController.py
# Command line usage
python SolutionController.py <product> "<task>" <architecture> [build_type]
# Examples:
python SolutionController.py standalone "🔨 Build" default Debug
python SolutionController.py both "🦸 Zero to Hero" default Release
python SolutionController.py emscripten "🚀 Launch Emscripten Server" noNeedArch
# Note: Help system documentation is in development
# For complete task list, use VSCode tasks menu (Shift+F7)Automatic documentation generation with Doxygen:
# Generate documentation
python SolutionController.py both "📖 Doxygen documentation generation" noNeedArch# Open the generated documentation in your browser (Linux)
xdg-open doc/html/index.html- API Reference: Generated from source code comments
- User Guide: Comprehensive usage examples
- Developer Guide: Contribution guidelines and architecture
- Changelog: Version history and migration guides
MIT License
Copyright (c) 2024-2025 Tomáš Mark
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This template is provided "as is" without warranties of any kind. While extensively tested across multiple platforms and continuously maintained, users must validate that the template meets their specific requirements before production use. The template undergoes regular updates to maintain compatibility with evolving toolchains and dependencies.
Key Considerations:
- Verify all dependencies and tools are compatible with your target environment
- Test thoroughly in your specific development and deployment scenarios
- Some features (marked as TODO) are planned but not yet implemented
- Cross-platform builds may require additional configuration on certain systems
Happy coding! 🚀🚀🚀
For support, questions, or suggestions, please open an issue or start a discussion.
This is a public version of the DotNameCpp project.
This repository contains carefully selected files from the main project that are suitable for public sharing and collaboration.
The content of this repository is automatically synchronized using GitHub Actions.
- Last synchronization: 2025-08-23 10:15:18 UTC
- Source commit:
5f83eff - Synchronization rules: Controlled by automated configuration
If you find this project useful or have suggestions for improvement, feel free to:
- ⭐ Star this repository
- 🐛 Report issues or bugs
- 💡 Suggest new features
- 🔄 Submit pull requests
For questions about this project or collaboration opportunities, please create an issue in this repository.