SyntxCode Demo

HTML


<div class="container">
  <h1>Hello World</h1>
</div>

CSS


h1 {
  color: red;
  margin: 1rem;
}

JavaScript (Dark Theme)


function add(a, b) {
  return a + b;
}

Github Dark Theme


h1 {
  color: red;
  margin: 1rem;
}

Ruby (Light Theme)


module MathUtils
  PI = 3.1415

  def self.circle_area(radius)
    PI * radius**2
  end
end

# comment
radius = 5
puts "Circle area: #{MathUtils.circle_area(radius)}"

email_pattern = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
email = "test@example.com"
puts "Email valid" if email =~ email_pattern

Python


import math
from typing import List

class Circle:
    """A circle class with area calculation"""

    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return math.pi * self.radius ** 2

def calculate_stats(numbers: List[int]) -> tuple:
    "Calculate mean and standard deviation"
    n = len(numbers)
    mean = sum(numbers) / n
    variance = sum((x - mean) ** 2 for x in numbers) / n
    return (mean, math.sqrt(variance))

# Example usage
my_circle = Circle(5.0)
print(f"Area: {my_circle.area():.2f}")

data = [1, 2, 3, 4, 5]
mean, std_dev = calculate_stats(data)
print(f"Mean: {mean}, Std Dev: {std_dev:.2f}")

C# (Dark Theme)


using System;
using System.Collections.Generic;

namespace Geometry
{
    public interface IShape
    {
        double Area();
        double Perimeter();
    }

    public class Circle : IShape
    {
        public double Radius { get; set; }

        public Circle(double radius)
        {
            Radius = radius;
        }

        public double Area() => Math.PI * Math.Pow(Radius, 2);

        public double Perimeter() => 2 * Math.PI * Radius;
    }

    public static class MathUtils
    {
        public static (double, double) CalculateStats(List<int> numbers)
        {
            var n = numbers.Count;
            var mean = numbers.Sum() / (double)n;
            var variance = numbers.Sum(x => Math.Pow(x - mean, 2)) / n;
            return (mean, Math.Sqrt(variance));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var circle = new Circle(5.0);
            Console.WriteLine($"Area: {circle.Area():F2}");
            Console.WriteLine($"Circumference: {circle.Perimeter():F2}");

            var data = new List<int> { 1, 2, 3, 4, 5 };
            var (mean, stdDev) = MathUtils.CalculateStats(data);
            Console.WriteLine($"Mean: {mean}, Std Dev: {stdDev:F2}");
        }
    }
}

C++ (GitHub Dark Theme)


#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

class Shape {
public:
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
    double radius;

public:
    Circle(double r) : radius(r) {}

    double area() const override {
        return M_PI * radius * radius;
    }

    double perimeter() const override {
        return 2 * M_PI * radius;
    }
};

double calculate_mean(const vector<int>& data) {
    double sum = 0;
    for (int val : data) {
        sum += val;
    }
    return sum / data.size();
}

double calculate_std_dev(const vector<int>& data, double mean) {
    double variance = 0;
    for (int val : data) {
        variance += pow(val - mean, 2);
    }
    variance /= data.size();
    return sqrt(variance);
}

int main() {
    Circle circle(5.0);
    cout << "Area: " << circle.area() << endl;
    cout << "Circumference: " << circle.perimeter() << endl;

    vector<int> data = {1, 2, 3, 4, 5};
    double mean = calculate_mean(data);
    double std_dev = calculate_std_dev(data, mean);

    cout << "Mean: " << mean << ", Std Dev: " << std_dev << endl;

    return 0;
}