Alpha.tpp → C++20
“a language for competitive programming that knows its purpose.”
Write less contest ceremony. Keep your attention on the algorithm. Emit C++20 for the toolchain you already know.
See current support
Current implementation
TPPL is a working but deliberately small alpha. It compiles a useful typed subset end to end, but it does not yet cover every competitive-programming problem.
Implemented from .tpp source through generated C++20 and g++.
Parsed and semantically checked, but not emitted by the C++ backend.
Not part of the current language. No release date is promised.
Current boundary: vector<T> is TPPL's only composite container, and user-defined data types are not available yet.
The language, first
Functions, vectors, ranges and output stay direct. The syntax remains familiar, while the compiler handles the semantic work before C++ is emitted.
int square(int x) {
return x * x;
}
int main() {
vector<int> answers = vector<int>(5, 0);
for i in 0..5 {
answers[i] = square(i + 1);
}
for answer in answers {
print(answer);
}
return 0;
}1
4
9
16
25Same problem. Less ceremony.
Read n. Visit [0, n). Print the even values. Both programs do exactly that.
#include <cstdint>
#include <iostream>
int main() {
std::int64_t n = 0;
std::cin >> n;
for (std::int64_t i = 0; i < n; ++i) {
if (i % 2 == 0) {
std::cout << i << '\n';
}
}
}int main() {
int n = read_int();
for i in 0..n {
if i % 2 == 0 {
print(i);
}
}
return 0;
}Why TPPL?
Spend fewer keystrokes on ceremony and more attention on the algorithm.
Functions, control flow, vectors and I/O are shaped around the work of solving.
A real frontend checks your program, lowers it to typed IR and emits C++20 for g++.
Language showcase
Version 0.01 Alpha focuses on a compact, typed subset that already reaches executable C++20.
Pass values directly, return strings, and use resolved string operations.
string decorate(string word, char marker) {
word.push(marker);
return word;
}
int main() {
print(decorate("TPPL", '!'));
return 0;
}Ranges, branches and loop control keep the interesting path easy to scan.
int main() {
for value in -2..=2 {
if value == 0 {
continue;
}
print(value);
}
return 0;
}Recursive vector types and checked indexing cover familiar contest storage.
int main() {
vector<vector<int>> matrix =
vector<vector<int>>(3, vector<int>(4, 0));
matrix[1][2] = 5;
print(matrix[1][2]);
return 0;
}Read signed integers, byte strings and chars through the built-in runtime.
int main() {
int count = read_int();
string word = read_string();
char marker = read_char();
print(count);
print(word);
print(marker);
return 0;
}How it works
TPPL builds a syntax tree, resolves declarations, checks types and control flow, then creates an owning Lowered IR before C++ generation.
Reliability
Tests cover the frontend, semantic passes, lowering, runtime boundaries, deterministic output and the real C++ toolchain.
Get started
TPPL currently builds from source. pseudo --emit-cpp writes C++ source; invoking g++ and running the executable are separate CLI steps.
g++ for generated outputgit clone https://github.com/koljaPl/pseudo-programming-language.git
cd pseudo-programming-language
cmake -S . -B build \
-DCMAKE_BUILD_TYPE=Release \
-DBUILD_TESTING=OFF
cmake --build build --parallel
./build/pseudo --emit-cpp solution.tpp > solution.cpp
g++ -std=c++20 -Iruntime/include solution.cpp -o solution
./solutionOpen source
TPPL is fully open source. Contributions, experiments and grounded ideas are welcome.
Explore the sourceCreated by
The Pseudo Programming Language was created before his 16th birthday.
He considers this the youngest age at which a programming language of this scale has been created.
nikolya.plugin@gmail.comYour next submission
Focus on the solution. Let TPPL carry it to C++20.