Reworded MDX Example

This is an example of some MDX content. It is designed to demonstrate how to reword text while keeping the original meaning.

Here is a code block:

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

And here is an image:

Finally, here is a link to Google.

def my_function():
 print("This is a Python code block.")

```bash
echo "This is a bash command"

```json
{
 "key": "value"
}

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

```typescript
function add(x: number, y: number): number {
 return x + y;
}

```html
<p>This is HTML content</p>

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

```md
This is a markdown code block.

```go
package main


import "fmt"


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

```csharp
using System;


public class HelloWorld
{
 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!")
}

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

```ruby
puts "Hello, World!"

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

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

```text
This is a plain text code block.

```xml
<root>
 <element>Value</element>
</root>

```yaml
key: value

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

```sql
SELECT * FROM table_name;

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

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

```fsharp
printfn "Hello, World!"

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

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


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

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

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


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

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

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

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

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

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

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


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

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


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4 ; sys_write
 mov ebx, 1 ; stdout
 mov ecx, msg ; message address
 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

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

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

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

```ocaml
print_endline "Hello, World!"

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

```prolog
:- initialization(main).


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

```smalltalk
Transcript show: 'Hello, World!'.

```tcl
puts "Hello, World!"

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

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


entity hello is
end hello;


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

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

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

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


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

```apl
'Hello, World!'

```basic
PRINT "Hello, World!"

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

```d
import std.stdio;


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

```eiffel
class
 HELLO_WORLD


create
 make


feature


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


end

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

```groovy
println "Hello, World!"

```idris
module Main


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

```j
'Hello, World!'

```k
/ "Hello, World!"

```labview
# LabVIEW code would be represented visually.  This is a placeholder.

```maxima
print("Hello, World!");

```nim
echo "Hello, World!"

```q
"Hello, World!"

```rexx
say 'Hello, World!'

```self
'Hello, World!' println.

```simula
BEGIN
 OUTTEXT("Hello, World!");
 OUTIMAGE;
END

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

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

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

```zsh
echo "Hello, World!"

```apl
'Hello, World!'

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

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

```c++
#include <iostream>


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

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

```crystal
puts "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").

```fsharp
printfn "Hello, World!"

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

```go
package main


import "fmt"


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

```groovy
println "Hello, World!"

```haskell
main :: IO ()
main = putStrLn "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!")
}

```lisp
(print "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!";
?>

```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 HelloWorld {
 def main(args: Array[String]): Unit = {
 println("Hello, World!")
 }
}

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

```smalltalk
Transcript show: 'Hello, World!'.

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

```tcl
puts "Hello, World!"

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

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

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

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

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

```zsh
echo "Hello, World!"

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


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

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


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4 ; sys_write
 mov ebx, 1 ; stdout
 mov ecx, msg ; message address
 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

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

```basic
PRINT "Hello, World!"

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

```c++
#include <iostream>


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

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

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

```crystal
puts "Hello, World!"

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

```eiffel
class
 HELLO_WORLD


create
 make


feature


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


end

```elm
import Html exposing (text)


main =
 text "Hello, World!"

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


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

```fsharp
printfn "Hello, World!"

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

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

```go
package main


import "fmt"


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

```groovy
println "Hello, World!"

```haskell
main :: IO ()
main = putStrLn "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!")

```k
/ "Hello, World!"

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

```labview
# LabVIEW code would be represented visually.  This is a placeholder.

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

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

```maxima
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!";
?>

```prolog
:- initialization(main).


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

```q
"Hello, World!"

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

```rexx
say 'Hello, World!'

```ruby
puts "Hello, World!"

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

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

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

```self
'Hello, World!' println.

```simula
BEGIN
 OUTTEXT("Hello, World!");
 OUTIMAGE;
END

```smalltalk
Transcript show: 'Hello, World!'.

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

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

```tcl
puts "Hello, World!"

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

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

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

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


entity hello is
end hello;


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

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

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

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

```xml
<root>
 <element>Value</element>
</root>

```yaml
key: value

```zsh
echo "Hello, World!"

```apl
'Hello, World!'

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


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4 ; sys_write
 mov ebx, 1 ; stdout
 mov ecx, msg ; message address
 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

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

```basic
PRINT "Hello, World!"

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

```c++
#include <iostream>


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

```csharp
using System;


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

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

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

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

```crystal
puts "Hello, World!"

```d
import std.stdio;


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

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

```eiffel
class
 HELLO_WORLD


create
 make


feature


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


end

```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").

```fsharp
printfn "Hello, World!"

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

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

```go
package main


import "fmt"


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

```groovy
println "Hello, World!"

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

```html
<p>This is HTML content</p>

```idris
module Main


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

```j
'Hello, World!'

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

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

```json
{
 "key": "value"
}

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

```k
/ "Hello, World!"

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

```labview
# LabVIEW code would be represented visually.  This is a placeholder.

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

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

```markdown
This is a markdown code block.

```maxima
print("Hello, World!");

```nim
echo "Hello, World!"

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


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

```ocaml
print_endline "Hello, World!"

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

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

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

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

```prolog
:- initialization(main).


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

```q
"Hello, World!"

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

```rexx
say 'Hello, World!'

```ruby
puts "Hello, World!"

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

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

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

```self
'Hello, World!' println.

```simula
BEGIN
 OUTTEXT("Hello, World!");
 OUTIMAGE;
END

```smalltalk
Transcript show: 'Hello, World!'.

```sql
SELECT * FROM table_name;

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

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

```tcl
puts "Hello, World!"

```text
This is a plain text code block.

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

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

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

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


entity hello is
end hello;


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

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

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

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

```xml
<root>
 <element>Value</element>
</root>

```yaml
key: value

```zsh
echo "Hello, World!"

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

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

```go
package main


import "fmt"


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

---
title: "Reworded MDX Example"
description: "An example MDX document that has been reworded."
---


# Reworded MDX Example


This is an illustration featuring some MDX-formatted content. It's purpose is to show you how to change the wording of text whilst ensuring the original meaning is preserved.


Here's a code snippet:


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

And here's a visual:

Finally, check out this link to Google.

def my_function():
 print("This is a Python code block.")

```bash
echo "This is a bash command"

```json
{
 "key": "value"
}

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

```typescript
function add(x: number, y: number): number {
 return x + y;
}

```html
<p>This is HTML content</p>

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

```md
This is a markdown code block.

```go
package main


import "fmt"


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

```csharp
using System;


public class HelloWorld
{
 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!")
}

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

```ruby
puts "Hello, World!"

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

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

```text
This is a plain text code block.

```xml
<root>
 <element>Value</element>
</root>

```yaml
key: value

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

```sql
SELECT * FROM table_name;

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

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

```fsharp
printfn "Hello, World!"

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

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


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

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

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


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

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

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

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

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

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

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


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

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


section .text
 global _start


_start:
 ; Write to stdout
 mov eax, 4 ; sys_write
 mov ebx, 1 ; stdout
 mov ecx, msg ; message address
 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

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

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

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

```ocaml
print_endline "Hello, World!"

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

```prolog
:- initialization(main).


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

```smalltalk
Transcript show: 'Hello, World!'.

```tcl
puts "Hello, World!"

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

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


entity hello is
end hello;


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

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

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

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


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

```apl
'Hello, World!'

```basic
PRINT "Hello, World!"

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

```d
import std.stdio;


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

```eiffel
class
 HELLO_WORLD


create
 make


feature


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


end

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

```groovy
println "Hello, World!"

```idris
module Main


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

```j
'Hello, World!'

```k
/ "Hello, World!"

```labview
# LabVIEW code would be represented visually.  This is a placeholder.

```maxima
print("Hello, World!");

```nim
echo "Hello, World!"

```q
"Hello, World!"

```rexx
say 'Hello, World!'

```self
'Hello, World!' println.

<AppearanceSection></AppearanceSection>