Welcome to My Page

This is a simple example page. It demonstrates some basic MDX features.

function greet(name) {
 return `Hello, ${name}!`;
}


console.log(greet("World"));

Here's an image:

You can find more information here.

Let's add a list:

• Item 1
• Item 2
• Item 3

```python
def add(a, b):
 return a + b


print(add(5, 3))

And finally, some bold and italic text.

```javascript
console.log("This is another code block");

```jsx
function MyComponent() {
 return (
 <div>
 <h1>Hello from React!</h1>
 </div>
 );
}

Some more text after the code blocks.

This is a text block

```html
<p>This is an HTML paragraph.</p>

```css
body {
 background-color: lightblue;
}

```json
{
 "name": "example",
 "value": 123
}

```typescript
interface Person {
 name: string;
 age: number;
}


const person: Person = {
 name: "John",
 age: 30
};

```yaml
key1: value1
key2: value2

```bash
echo "Hello from the command line!"

```csharp
using System;


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

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

```kotlin
fun main() {
 println("Hello, World!")
}

```r
print("Hello, World!")

```swift
print("Hello, World!")

```go
package main


import "fmt"


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

```php
<?php
echo "Hello, World!";
?>

```ruby
puts "Hello, World!"

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

```rust
fn main() {
 println!("Hello, World!");
}

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


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

```lua
print("Hello, World!")

```perl
print "Hello, World!\n";

```dart
void main() {
 print('Hello, World!');
}

```fsharp
printfn "Hello, World!"

```coffeescript
console.log "Hello, World!"

```powershell
Write-Host "Hello, World!"

```assembly
section .data
 msg db 'Hello, World!', 0


section .text
 global _start


_start:
 ; Write to stdout
 mov rax, 1  ; sys_write
 mov rdi, 1  ; stdout
 mov rsi, msg ; message address
 mov rdx, 13 ; message length
 syscall


 ; Exit program
 mov rax, 60 ; sys_exit
 xor rdi, rdi ; exit code 0
 syscall

```fortran
program hello
 print *, "Hello, World!"
end program hello

```ada
with Ada.Text_IO; use Ada.Text_IO;


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

```pascal
program HelloWorld;
begin
 writeln('Hello, World!');
end.

```lisp
(print "Hello, World!")

```scheme
(display "Hello, World!")
(newline)

```prolog
:- initialization(main).


main :-
 write('Hello, World!'),
 nl.

```haskell
main :: IO ()
main = putStrLn "Hello, World!"

This is the end of the page.

This is a markdown block

```reStructuredText
Hello, World!
=============

```tex
\documentclass{article}
\begin{document}
Hello, World!
\end{document}

```xml
<?xml version="1.0" encoding="UTF-8"?>
<message>Hello, World!</message>

```csv
Header1,Header2
Value1,Value2

```ini
[Section]
key = value

```toml
key = "value"

```dockerfile
FROM ubuntu:latest


RUN apt-get update && apt-get install -y --no-install-recommends cowsay


CMD cowsay "Hello, Docker!"

```graphql
query {
 hello
}

```sparql
SELECT * WHERE {
 ?s ?p ?o .
 FILTER regex(str(?o), "Hello, World!")
}

```mathematica
Print["Hello, World!"]

```matlab
disp('Hello, World!')

```julia
println("Hello, World!")

```octave
disp("Hello, World!")

```vhdl
library ieee;
use ieee.std_logic_1164.all;


entity hello is
end entity hello;


architecture behavioral of hello is
begin
 process
 begin
 report "Hello, World!" severity note;
 wait;
 end process;
end architecture behavioral;

```verilog
module hello;
 initial begin
 $display("Hello, World!");
 $finish;
 end
endmodule

```systemverilog
module hello;
 initial begin
 $display("Hello, World!");
 $finish;
 end
endmodule

```ada
with Ada.Text_IO; use Ada.Text_IO;


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, World!".
 STOP RUN.

```forth
." Hello, World!" cr
bye

```apl
'Hello, World!'

```awk
BEGIN { print "Hello, World!" }

```bc
print "Hello, World!"
quit

```clojure
(println "Hello, World!")

```d
import std.stdio;


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

```elixir
IO.puts "Hello, World!"

```elm
import Html exposing (text)


main =
 text "Hello, World!"

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


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

```factor
"Hello, World!" print

```gforth
." Hello, World!" cr
bye

```groovy
println "Hello, World!"

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

```idris
module Main


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

```j
'Hello, World!'

```javascript
console.log("Hello, World!");

```julia
println("Hello, World!")

```kotlin
fun main() {
 println("Hello, World!")
}

```lisp
(print "Hello, World!")

```lua
print("Hello, World!")

```matlab
disp('Hello, World!')

```nim
echo "Hello, World!"

```objectivec
#import <Foundation/Foundation.h>


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

```ocaml
print_endline "Hello, World!"

```pascal
program HelloWorld;
begin
 writeln('Hello, World!');
end.

```perl
print "Hello, World!\n";

```php
<?php
echo "Hello, World!";
?>

```prolog
:- initialization(main).


main :-
 write('Hello, World!'),
 nl.

```python
print("Hello, World!")

```r
print("Hello, World!")

```ruby
puts "Hello, World!"

```rust
fn main() {
 println!("Hello, World!");
}

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

```scheme
(display "Hello, World!")
(newline)

```swift
print("Hello, World!")

```typescript
console.log("Hello, World!");

```vbnet
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```visualbasic
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```wolframlanguage
Print["Hello, World!"]

```zig
const std = @import("std");


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

```brainfuck
++++++++[>++++++++<-]>++++.+++++++..+++.>.+++++++..++++++++++.>.<<+++++++++++++++.>.+++.------.--------.>+.>.

```c
#include <stdio.h>


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

```cpp
#include <iostream>


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

```csharp
using System;


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

```cuda
#include <iostream>


__global__ void helloWorld() {
 printf("Hello, World from GPU!\n");
}


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

```objectivec
#import <Foundation/Foundation.h>


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

```delphi
program HelloWorld;


begin
 WriteLn('Hello, World!');
end.

```forth
." Hello, World!" cr
bye

```fsharp
printfn "Hello, World!"

```go
package main


import "fmt"


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

```haskell
main :: IO ()
main = putStrLn "Hello, World!"

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

```javascript
console.log("Hello, World!");

```kotlin
fun main() {
 println("Hello, World!")
}

```lua
print("Hello, World!")

```objectivec
#import <Foundation/Foundation.h>


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

```pascal
program HelloWorld;
begin
 writeln('Hello, World!');
end.

```perl
print "Hello, World!\n";

```php
<?php
echo "Hello, World!";
?>

```python
print("Hello, World!")

```r
print("Hello, World!")

```ruby
puts "Hello, World!"

```rust
fn main() {
 println!("Hello, World!");
}

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

```swift
print("Hello, World!")

```typescript
console.log("Hello, World!");

```vbnet
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```visualbasic
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```zig
const std = @import("std");


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

```brainfuck
++++++++[>++++++++<-]>++++.+++++++..+++.>.+++++++..++++++++++.>.<<+++++++++++++++.>.+++.------.--------.>+.>.

```c
#include <stdio.h>


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

```cpp
#include <iostream>


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

```csharp
using System;


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

```cuda
#include <iostream>


__global__ void helloWorld() {
 printf("Hello, World from GPU!\n");
}


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

```delphi
program HelloWorld;


begin
 WriteLn('Hello, World!');
end.

```dart
void main() {
 print('Hello, World!');
}

```elixir
IO.puts "Hello, World!"

```elm
import Html exposing (text)


main =
 text "Hello, World!"

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


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

```factor
"Hello, World!" print

```fsharp
printfn "Hello, World!"

```go
package main


import "fmt"


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

```groovy
println "Hello, World!"

```haskell
main :: IO ()
main = putStrLn "Hello, World!"

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

```idris
module Main


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

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

```javascript
console.log("Hello, World!");

```julia
println("Hello, World!")

```kotlin
fun main() {
 println("Hello, World!")
}

```lua
print("Hello, World!")

```nim
echo "Hello, World!"

```objectivec
#import <Foundation/Foundation.h>


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

```ocaml
print_endline "Hello, World!"

```pascal
program HelloWorld;
begin
 writeln('Hello, World!');
end.

```perl
print "Hello, World!\n";

```php
<?php
echo "Hello, World!";
?>

```python
print("Hello, World!")

```r
print("Hello, World!")

```ruby
puts "Hello, World!"

```rust
fn main() {
 println!("Hello, World!");
}

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

```swift
print("Hello, World!")

```typescript
console.log("Hello, World!");

```vbnet
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```visualbasic
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```zig
const std = @import("std");


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

```brainfuck
++++++++[>++++++++<-]>++++.+++++++..+++.>.+++++++..++++++++++.>.<<+++++++++++++++.>.+++.------.--------.>+.>.

```c
#include <stdio.h>


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

```cpp
#include <iostream>


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

```csharp
using System;


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

```cuda
#include <iostream>


__global__ void helloWorld() {
 printf("Hello, World from GPU!\n");
}


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

```delphi
program HelloWorld;


begin
 WriteLn('Hello, World!');
end.

```dart
void main() {
 print('Hello, World!');
}

```elixir
IO.puts "Hello, World!"

```elm
import Html exposing (text)


main =
 text "Hello, World!"

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


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

```factor
"Hello, World!" print

```fsharp
printfn "Hello, World!"

```go
package main


import "fmt"


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

```groovy
println "Hello, World!"

```haskell
main :: IO ()
main = putStrLn "Hello, World!"

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

```idris
module Main


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

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

```javascript
console.log("Hello, World!");

```julia
println("Hello, World!")

```kotlin
fun main() {
 println("Hello, World!")
}

```lua
print("Hello, World!")

```nim
echo "Hello, World!"

```objectivec
#import <Foundation/Foundation.h>


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

```ocaml
print_endline "Hello, World!"

```pascal
program HelloWorld;
begin
 writeln('Hello, World!');
end.

```perl
print "Hello, World!\n";

```php
<?php
echo "Hello, World!";
?>

```python
print("Hello, World!")

```r
print("Hello, World!")

```ruby
puts "Hello, World!"

```rust
fn main() {
 println!("Hello, World!");
}

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

```swift
print("Hello, World!")

```typescript
console.log("Hello, World!");

```vbnet
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```visualbasic
Module Program
 Sub Main()
 Console.WriteLine("Hello, World!")
 End Sub
End Module

```zig
const std = @import("std");


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

```brainfuck
++++++++[>++++++++<-]>++++.+++++++..+++.>.+++++++..++++++++++.>.<<+++++++++++++++.>.+++.------.--------.>+.>.

```c
#include <stdio.h>


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

```cpp
#include <iostream>


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

```csharp
using System;


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

```cuda
#include <iostream>


__global__ void helloWorld() {
 printf("Hello, World from GPU!\n");
}


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

```delphi
program HelloWorld;


begin
 WriteLn('Hello, World!');
end.

```dart
void main() {
 print('Hello, World!');
}

```elixir
IO.puts "Hello, World!"

```elm
import Html exposing (text)


main =
 text "Hello, World!"

---
title: "My Awesome Page"
date: 2023-10-27
---


# Take a Look at My Page!


This page serves as a basic illustration. It showcases a few fundamental capabilities of MDX.


```javascript
function greet(name) {
 return `Hello, ${name}!`;
}


console.log(greet("World"));

Check out this image:

More details can be located here.

How about we include a list?

• First Item
• Second Item
• Third Item

```python
def add(a, b):
 return a + b


print(add(5, 3))

Finally, some prominent and slanted text.

```javascript
console.log("This is another code block");

```jsx
function MyComponent() {
 return (
 <div>
 <h1>Hello from React!</h1>
 </div>
 );
}

Some more text after the code blocks.

This is a text block

```html
<p>This is an HTML paragraph.</p>

```css
body {
 background-color: lightblue;
}

```json
{
 "name": "example",
 "value": 123
}

```typescript
interface Person {
 name: string;
 age: number;
}


const person: Person = {
 name: "John",
 age: 30
};

```yaml
key1: value1
key2: value2

```bash
echo "Hello from the command line!"

```csharp
using System;


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

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

```kotlin
fun main() {
 println("Hello, World!")
}

```r
print("Hello, World!")

```swift
print("Hello, World!")

```go
package main


import "fmt"


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

```php
<?php
echo "Hello, World!";
?>

```ruby
puts "Hello, World!"

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

```rust
fn main() {
 println!("Hello, World!");
}

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


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

```lua
print("Hello, World!")

```perl
print "Hello, World!\n";

```dart
void main() {
 print('Hello, World!');
}

```fsharp
printfn "Hello, World!"

```coffeescript
console.log "Hello, World!"

```powershell
Write-Host "Hello, World!"

```assembly
section .data
 msg db 'Hello, World!', 0


section .text
 global _start


_start:
 ; Write to stdout
 mov rax, 1  ; sys_write
 mov rdi, 1  ; stdout
 mov rsi, msg ; message address
 mov rdx, 13 ; message length
 syscall


 ; Exit program
 mov rax, 60 ; sys_exit
 xor rdi, rdi ; exit code 0
 syscall

```fortran
program hello
 print *, "Hello, World!"
end program hello

```ada
with Ada.Text_IO; use Ada.Text_IO;


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

```pascal
program HelloWorld;
begin
 writeln('Hello, World!');
end.

```lisp
(print "Hello, World!")

```scheme
(display "Hello, World!")
(newline)

```prolog
:- initialization(main).


main :-
 write('Hello, World!'),
 nl.

```haskell
main :: IO ()
main = putStrLn "Hello, World!"

This is the conclusion of the page.

This is a markdown block

```reStructuredText
Hello, World!
=============

```tex
\documentclass{article}
\begin{document}
Hello, World!
\end{document}

```xml
<?xml version="1.0" encoding="UTF-8"?>
<message>Hello, World!</message>

```csv
Header1,Header2
Value1,Value2

```ini
[Section]
key = value

```toml
key = "value"

```dockerfile
FROM ubuntu:latest


RUN apt-get update && apt-get install -y --no-install-recommends cowsay


CMD cowsay "Hello, Docker!"

```graphql
query {
 hello
}

```sparql
SELECT * WHERE {
 ?s ?p ?o .
 FILTER regex(str(?o), "Hello, World!")
}

```mathematica
Print["Hello, World!"]

```matlab
disp('Hello, World!')

```julia
println("Hello, World!")

```octave
disp("Hello, World!")

```vhdl
library ieee;
use ieee.std_logic_1164.all;


entity hello is
end entity hello;


architecture behavioral of hello is
begin
 process
 begin
 report "Hello, World!" severity note;
 wait;
 end process;
end architecture behavioral;

```verilog
module hello;
 initial begin
 $display("Hello, World!");
 $finish;
 end
endmodule

```systemverilog
module hello;
 initial begin
 $display("Hello, World!");
 $finish;
 end
endmodule

```ada
with Ada.Text_IO; use Ada.Text_IO;


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, World!".
 STOP RUN.

```forth
." Hello, World!" cr
bye

```apl
'Hello, World!'

```awk
BEGIN { print "Hello, World!" }

```bc
print "Hello, World!"
quit

```clojure
(println "Hello, World!")

```d
import std.stdio;


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

```elixir
IO.puts "Hello, World!"

```elm
import Html exposing (text)


main =
 text "Hello, World!"

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


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

```factor
"Hello, World!" print

```gforth
." Hello, World!" cr
bye

```groovy
println "Hello, World!"

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

```idris
module Main


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

```j
'Hello, World!'

```javascript
console.log("Hello, World!");

```julia
println("Hello, World!")

```kotlin
fun main() {
 println("Hello, World!")
}

```lisp
(print "Hello, World!")

```lua
print("Hello, World!")

```matlab
disp('Hello, World!')

```nim
echo "Hello, World!"

```objectivec
#import <Foundation/Foundation.h>


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

```ocaml
print_endline "Hello, World!"