Welcome to my MDX page!

This is an example of how you can use MDX to write content with React components.

Here's an example of an image:

You can also include code snippets:

function helloWorld() {
 console.log("Hello, world!");
}


helloWorld();

And links to external resources: React Documentation.

Let's try using bold and italic text.

Finally, here is a list:

• Item 1
• Item 2
• Item 3

print("Hello, Python!")

echo "Hello, Bash!"

console.log("Hello, TypeScript!");

{
 "message": "Hello, JSON!"
}

const element = <h1>Hello, JSX!</h1>;

<p>Hello, HTML!</p>

body {
 background-color: lightblue;
}

public class Main {
 public static void main(String[] args) {
 System.out.println("Hello, Java!");
 }
}

using System;


public class Program {
 public static void Main(string[] args) {
 Console.WriteLine("Hello, C#!");
 }
}

package main


import "fmt"


func main() {
 fmt.Println("Hello, Go!")
}

fun main() {
 println("Hello, Kotlin!")
}

puts "Hello, Ruby!"

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello, Scala!")
 }
}

print("Hello, Swift!")

<?php
echo "Hello, PHP!";
?>

print("Hello, R!")

void main() {
 print('Hello, Dart!');
}

-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Hello, Erlang!~n").

IO.puts "Hello, Elixir!"

print("Hello, Lua!")

print "Hello, Perl!\n";

console.log "Hello, CoffeeScript!"

printfn "Hello, F#!"

Write-Host "Hello, PowerShell!"

fn main() {
 println!("Hello, Rust!");
}

Module Program
 Sub Main()
 Console.WriteLine("Hello, VB.NET!")
 End Sub
End Module

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello, Objective-C!");
 }
 return 0;
}

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line ("Hello, Ada!");
end Hello;

section .data
 msg db 'Hello, Assembly!', 0


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4  ; sys_write
 mov ebx, 1  ; stdout
 mov ecx, msg
 mov edx, 16 ; message length
 int 0x80  ; call kernel


 ; Exit program
 mov eax, 1  ; sys_exit
 xor ebx, ebx ; exit code 0
 int 0x80  ; call kernel

program hello
 print *, "Hello, Fortran!"
end program hello

program Hello;
begin
 writeln('Hello, Pascal!');
end.

hello :-
 write('Hello, Prolog!'), nl.

(display "Hello, Scheme!")
(newline)

puts "Hello, Tcl!"

(print "Hello, Lisp!")

(println "Hello, Clojure!")

main :: IO ()
main = putStrLn "Hello, Haskell!"

-module(hello).
-export([start/0]).


start() ->
 io:format("Hello, Erlang!~n").

println("Hello, Julia!")

Print["Hello, Mathematica!"]

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL.".
 STOP RUN.

program Hello;


begin
 Writeln('Hello, Delphi!');
end.

'Hello, APL!'

BEGIN { print "Hello, Awk!" }

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

#import <iostream>


int main() {
 std::cout << "Hello, Objective-C++!" << std::endl;
 return 0;
}

#include <iostream>


__global__ void helloCuda() {
 printf("Hello from GPU!\n");
}


int main() {
 helloCuda<<<1, 1>>>();
 cudaDeviceSynchronize();
 return 0;
}

import std.stdio;


void main() {
 writeln("Hello, D!");
}

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Hello, Eiffel!%N")
 end


end

: HELLO ." Hello, Forth!" ;
HELLO

println "Hello, Groovy!"

class Main {
 static function main() {
 Sys.println("Hello, Haxe!");
 }
}

"Hello, Io!" println

'Hello, J!'

echo "Hello, Nim!"

@import Foundation;


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello, Objective-J!");
 }
 return 0;
}

print_endline "Hello, OCaml!";

program Hello;
begin
 writeln('Hello, Pascal!');
end.

void setup() {
 println("Hello, Processing!");
}

"Hello, Q!"

print "Hello, Rebol!"

Transcript show: 'Hello, Smalltalk!'; cr.

print "Hello, SML!\n";

module hello;
 initial begin
 $display("Hello, SystemVerilog!");
 end
endmodule

int main() {
 print("Hello, Vala!\n");
 return 0;
}

module hello;
 initial begin
 $display("Hello, Verilog!");
 end
endmodule

Module Program
 Sub Main()
 Console.WriteLine("Hello, Visual Basic!");
 End Sub
End Module

Print["Hello, Wolfram Language!"]

echo "Hello, Zsh!"

console.log("Hello, AssemblyScript!");

import ballerina/io;


public function main() {
 io:println("Hello, Ballerina!");
}

#include <iostream>


int main() {
 std::cout << "Hello, Cilk!" << std::endl;
 return 0;
}

(println "Hello, ClojureScript!")

puts "Hello, Crystal!"

#include <iostream>


__global__ void helloCuda() {
 printf("Hello from GPU using CUDA!\n");
}


int main() {
 helloCuda<<<1, 1>>>();
 cudaDeviceSynchronize();
 return 0;
}

import Html exposing (text)


main =
 text "Hello, Elm!"

-module(hello).
-export([start/0]).


start() ->
 io:format("Hello from Erlang!~n").

"Hello, Factor!" print

program Hello;
begin
 writeln('Hello from Free Pascal!');
end.

module Main


main : IO ()
main = putStrLn "Hello, Idris!"

(print "Hello, Janet!")

console.log "Hello, LiveScript!"

(`<|vx\4/ts'rqponmlkjihgfedcba`9876543210/.-,+*)('&%$#"!

.data
 msg: .asciiz "Hello, MIPS!\n"


.text
.globl main


main:
 li $v0, 4 # system call code for print string
 la $a0, msg # address of string to print
 syscall # print the string


 li $v0, 10 # system call code for exit
 syscall # exit the program

SELECT "Hello, MySQL!";

section .data
 msg db 'Hello, NASM!', 0


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4  ; sys_write
 mov ebx, 1  ; stdout
 mov ecx, msg
 mov edx, 13 ; message length
 int 0x80  ; call kernel


 ; Exit program
 mov eax, 1  ; sys_exit
 xor ebx, ebx ; exit code 0
 int 0x80  ; call kernel

disp("Hello, Octave!")

program Hello;
begin
 writeln('Hello from Pascal!');
end.

Write-Host "Hello from PowerShell!"

#lang racket
(displayln "Hello, Racket!")

print_endline("Hello, ReasonML!");

fn main() {
 println!("Hello from Rust!");
}

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

console.log("Hello from TypeScript!");

main = putStrLn "Hello, Unison!"

fn main() {
 println('Hello, V!')
}

(module
 (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
 (import "wasi_snapshot_preview1" "proc_exit" (func $proc_exit (param i32)))
 (memory (export "memory") 1)
 (data (i32.const 0) "Hello, WASM!\n")
 (func (export "_start")
 (local $len i32)
 (local $addr i32)
 (local.set $addr (i32.const 0))
 (local.set $len (i32.const 14))
 (call $fd_write (i32.const 1) (local.get $addr) (local.get $len) (i32.const 1024))
 (call $proc_exit (i32.const 0))
 )
)

<?xml version="1.0"?>
<greeting>Hello, XML!</greeting>

greeting: Hello, YAML!

const std = @import("std");


pub fn main() !void {
 const stdout = std.io.getStdOut().writer();
 try stdout.print("Hello, Zig!\n", .{});
}

using System;


public class Program {
 public static void Main(string[] args) {
 Console.WriteLine("Greetings from C#!");
 }
}

#include <iostream>


int main() {
 std::cout << "Greetings from C++!" << std::endl;
 return 0;
}

public class Main {
 public static void main(String[] args) {
 System.out.println("Greetings from Java!");
 }
}

function greetWorld() {
 console.log("Greetings, world!");
}


greetWorld();

<?php
echo "Greetings from PHP!";
?>

print("Greetings, Python!")

puts "Greetings from Ruby!"

print("Greetings from Swift!")

console.log("Greetings from TypeScript!");

fun main() {
 println("Greetings from Kotlin!")
}

package main


import "fmt"


func main() {
 fmt.Println("Greetings from Go!")
}

fn main() {
 println!("Greetings from Rust!");
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Greetings from Scala!")
 }
}

echo "Greetings from Bash!"

#include <stdio.h>


int main() {
 printf("Greetings from C!\n");
 return 0;
}

console.log "Greetings from CoffeeScript!"

using System;


public class Program {
 public static void Main(string[] args) {
 Console.WriteLine("Greetings from C#!");
 }
}

void main() {
 print('Greetings from Dart!');
}

program Hello;


begin
 Writeln('Greetings from Delphi!');
end.

IO.puts "Greetings from Elixir!"

-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Greetings from Erlang!~n").

printfn "Greetings from F#!"

program hello
 print *, "Greetings from Fortran!"
end program hello

println "Greetings from Groovy!"

main :: IO ()
main = putStrLn "Greetings from Haskell!"

class Main {
 static function main() {
 Sys.println("Greetings from Haxe!");
 }
}

println("Greetings from Julia!")

(print "Greetings from Lisp!")

print("Greetings from Lua!")

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Greetings from Objective-C!");
 }
 return 0;
}

program Hello;
begin
 writeln('Greetings from Pascal!');
end.

print "Greetings from Perl!\n";

Write-Host "Greetings from PowerShell!"

hello :-
 write('Greetings from Prolog!'), nl.

print("Greetings from R!")

#lang racket
(displayln "Greetings from Racket!")

print_endline("Greetings from ReasonML!");

print "Greetings from Rebol!"

fn main() {
 println!("Greetings from Rust!");
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Greetings from Scala!")
 }
}

(display "Greetings from Scheme!")
(newline)

Transcript show: 'Greetings from Smalltalk!'; cr.

print "Greetings from SML!\n";

print("Greetings from Swift!")

puts "Greetings from Tcl!"

console.log("Greetings from TypeScript!");

Module Program
 Sub Main()
 Console.WriteLine("Greetings from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Greetings from Verilog!");
 end
endmodule

int main() {
 print("Greetings from Vala!\n");
 return 0;
}

Module Program
 Sub Main()
 Console.WriteLine("Greetings from Visual Basic!");
 End Sub
End Module

Print["Greetings from Wolfram Language!"]

echo "Greetings from Zsh!"

const std = @import("std");


pub fn main() !void {
 const stdout = std.io.getStdOut().writer();
 try stdout.print("Greetings from Zig!\n", .{});
}

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line ("Greetings from Ada!");
end Hello;

'Greetings, APL!'

section .data
 msg db 'Greetings from Assembly!', 0


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4  ; sys_write
 mov ebx, 1  ; stdout
 mov ecx, msg
 mov edx, 22 ; message length
 int 0x80  ; call kernel


 ; Exit program
 mov eax, 1  ; sys_exit
 xor ebx, ebx ; exit code 0
 int 0x80  ; call kernel

console.log("Greetings from AssemblyScript!");

BEGIN { print "Greetings from Awk!" }

import ballerina/io;


public function main() {
 io:println("Greetings from Ballerina!");
}

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

#include <iostream>


int main() {
 std::cout << "Greetings from Cilk!" << std::endl;
 return 0;
}

(println "Greetings from Clojure!")

(println "Greetings from ClojureScript!")

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Greetings from COBOL.".
 STOP RUN.

console.log "Greetings from CoffeeScript!"

puts "Greetings from Crystal!"

#include <iostream>


__global__ void helloCuda() {
 printf("Greetings from GPU using CUDA!\n");
}


int main() {
 helloCuda<<<1, 1>>>();
 cudaDeviceSynchronize();
 return 0;
}

import std.stdio;


void main() {
 writeln("Greetings from D!");
}

void main() {
 print('Greetings from Dart!');
}

program Hello;


begin
 Writeln('Greetings from Delphi!');
end.

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Greetings from Eiffel!%N")
 end


end

IO.puts "Greetings from Elixir!"

import Html exposing (text)


main =
 text "Greetings from Elm!"

-module(hello).
-export([start/0]).


start() ->
 io:format("Greetings from Erlang!~n").

-module(hello).
-export([start/0]).


start() ->
 io:format("Greetings from Erlang!~n").

"Greetings from Factor!" print

program hello
 print *, "Greetings from Fortran!"
end program hello

program Hello;
begin
 writeln('Greetings from Free Pascal!');
end.

println "Greetings from Groovy!"

main :: IO ()
main = putStrLn "Greetings from Haskell!"

class Main {
 static function main() {
 Sys.println("Greetings from Haxe!");
 }
}

module Main


main : IO ()
main = putStrLn "Greetings from Idris!"

"Greetings from Io!" println

'Greetings, J!'

(print "Greetings from Janet!")

println("Greetings from Julia!")

(print "Greetings from Lisp!")

console.log "Greetings from LiveScript!"

print("Greetings from Lua!")

(`<|vx\4/ts'rqponmlkjihgfedcba`9876543210/.-,+*)('&%$#"!

Print["Greetings from Mathematica!"]

.data
 msg: .asciiz "Greetings from MIPS!\n"


.text
.globl main


main:
 li $v0, 4 # system call code for print string
 la $a0, msg # address of string to print
 syscall # print the string


 li $v0, 10 # system call code for exit
 syscall # exit the program

SELECT "Greetings from MySQL!";

section .data
 msg db 'Greetings from NASM!', 0


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4  ; sys_write
 mov ebx, 1  ; stdout
 mov ecx, msg
 mov edx, 19 ; message length
 int 0x80  ; call kernel


 ; Exit program
 mov eax, 1  ; sys_exit
 xor ebx, ebx ; exit code 0
 int 0x80  ; call kernel

echo "Greetings from Nim!"

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Greetings from Objective-C!");
 }
 return 0;
}

@import Foundation;


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Greetings from Objective-J!");
 }
 return 0;
}

print_endline "Greetings from OCaml!";

disp("Greetings from Octave!")

program Hello;
begin
 writeln('Greetings from Pascal!');
end.

program Hello;
begin
 writeln('Greetings from Pascal!');
end.

print "Greetings from Perl!\n";

<?php
echo "Greetings from PHP!";
?>

Write-Host "Greetings from PowerShell!"

void setup() {
 println("Greetings from Processing!");
}

hello :-
 write('Greetings from Prolog!'), nl.

"Greetings from Q!"

print("Greetings from R!")

#lang racket
(displayln "Greetings from Racket!")

print_endline("Greetings from ReasonML!");

print "Greetings from Rebol!"

puts "Greetings from Ruby!"

fn main() {
 println!("Greetings from Rust!");
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Greetings from Scala!")
 }
}

(display "Greetings from Scheme!")
(newline)

Transcript show: 'Greetings from Smalltalk!'; cr.

print "Greetings from SML!\n";

print("Greetings from Swift!")

module hello;
 initial begin
 $display("Greetings from SystemVerilog!");
 end
endmodule

puts "Greetings from Tcl!"

console.log("Greetings from TypeScript!");

main = putStrLn "Greetings from Unison!"

fn main() {
 println('Greetings from V!')
}

int main() {
 print("Greetings from Vala!\n");
 return 0;
}

Module Program
 Sub Main()
 Console.WriteLine("Greetings from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Greetings from Verilog!");
 end
endmodule

Module Program
 Sub Main()
 Console.WriteLine("Greetings from Visual Basic!");
 End Sub
End Module

(module
 (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
 (import "wasi_snapshot_preview1" "proc_exit" (func $proc_exit (param i32)))
 (memory (export "memory") 1)
 (data (i32.const 0) "Greetings from WASM!\n")
 (func (export "_start")
 (local $len i32)
 (local $addr i32)
 (local.set $addr (i32.const 0))
 (local.set $len (i32.const 21))
 (call $fd_write (i32.const 1) (local.get $addr) (local.get $len) (i32.const 1024))
 (call $proc_exit (i32.const 0))
 )
)

Print["Greetings from Wolfram Language!"]

<?xml version="1.0"?>
<greeting>Greetings from XML!</greeting>

greeting: Greetings from YAML!

echo "Greetings from Zsh!"

const std = @import("std");


pub fn main() !void {
 const stdout = std.io.getStdOut().writer();
 try stdout.print("Greetings from Zig!\n", .{});
}

using System;


public class Program {
 public static void Main(string[] args) {
 Console.WriteLine("Salutations from C#!");
 }
}

#include <iostream>


int main() {
 std::cout << "Salutations from C++!" << std::endl;
 return 0;
}

public class Main {
 public static void main(String[] args) {
 System.out.println("Salutations from Java!");
 }
}

function greetTheWorld() {
 console.log("Salutations, world!");
}


greetTheWorld();

<?php
echo "Salutations from PHP!";
?>

print("Salutations, Python!")

puts "Salutations from Ruby!"

print("Salutations from Swift!")

console.log("Salutations from TypeScript!");

fun main() {
 println("Salutations from Kotlin!")
}

package main


import "fmt"


func main() {
 fmt.Println("Salutations from Go!")
}

fn main() {
 println!("Salutations from Rust!");
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Salutations from Scala!")
 }
}

echo "Salutations from Bash!"

#include <stdio.h>


int main() {
 printf("Salutations from C!\n");
 return 0;
}

console.log "Salutations from CoffeeScript!"

using System;


public class Program {
 public static void Main(string[] args) {
 Console.WriteLine("Salutations from C#!");
 }
}

void main() {
 print('Salutations from Dart!');
}

program Hello;


begin
 Writeln('Salutations from Delphi!');
end.

IO.puts "Salutations from Elixir!"

-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Salutations from Erlang!~n").

printfn "Salutations from F#!"

program hello
 print *, "Salutations from Fortran!"
end program hello

println "Salutations from Groovy!"

main :: IO ()
main = putStrLn "Salutations from Haskell!"

class Main {
 static function main() {
 Sys.println("Salutations from Haxe!");
 }
}

println("Salutations from Julia!")

(print "Salutations from Lisp!")

print("Salutations from Lua!")

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Salutations from Objective-C!");
 }
 return 0;
}

program Hello;
begin
 writeln('Salutations from Pascal!');
end.

print "Salutations from Perl!\n";

Write-Host "Salutations from PowerShell!"

hello :-
 write('Salutations from Prolog!'), nl.

print("Salutations from R!")

#lang racket
(displayln "Salutations from Racket!")

print_endline("Salutations from ReasonML!");

print "Salutations from Rebol!"

fn main() {
 println!("Salutations from Rust!");
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Salutations from Scala!")
 }
}

(display "Salutations from Scheme!")
(newline)

Transcript show: 'Salutations from Smalltalk!'; cr.

print "Salutations from SML!\n";

print("Salutations from Swift!")

module hello;
 initial begin
 $display("Salutations from SystemVerilog!");
 end
endmodule

puts "Salutations from Tcl!"

console.log("Salutations from TypeScript!");

main = putStrLn "Salutations from Unison!"

fn main() {
 println('Salutations from V!')
}

int main() {
 print("Salutations from Vala!\n");
 return 0;
}

Module Program
 Sub Main()
 Console.WriteLine("Salutations from Visual Basic!");
 End Sub
End Module

module hello;
 initial begin
 $display("Salutations from Verilog!");
 end
endmodule

Module Program
 Sub Main()
 Console.WriteLine("Salutations from Visual Basic!");
 End Sub

<AppearanceSection></AppearanceSection>