Home

title: Reworded MDX Example description: An example MDX file that has been reworded.

A Freshly Phrased MDX Example

Let's examine some MDX content that has been re-written to demonstrate the capability.

Code Blocks

Here's a demonstration of a code block:

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


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

Images

Links

Check out Google for more information.

Lists

Here is an unordered list:

  • Item 1
  • Item 2
  • Item 3

And now, an ordered list:

  1. First item
  2. Second item
  3. Third item

Emphasis

This is italicized text. This is bold text.

Conclusion

This concludes our reworded MDX example. The purpose was to modify the wording while keeping the original meaning intact.

def factorial(n):
 if n == 0:
 return 1
 else:
 return n * factorial(n-1)


print(factorial(5))



```html
<p>This is a paragraph in HTML.</p>

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

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

```typescript
function add(a: number, b: number): number {
 return a + b;
}


console.log(add(2, 3));

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

```csharp
using System;


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

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

```ruby
puts "Hello, Ruby!"

```go
package main


import "fmt"


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

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

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

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

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

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

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


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

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

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

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

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

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

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

```fsharp
printfn "Hello, F#!"

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

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

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


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

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


section .text
 global _start


_start:
 ; Write "Hello, Assembly!" to stdout
 mov eax, 4 ; system call number for write
 mov ebx, 1 ; file descriptor 1 is stdout
 mov ecx, msg ; pointer to the message
 mov edx, 17 ; length of the message
 int 0x80 ; call the kernel


 ; Exit the program
 mov eax, 1 ; system call number for exit
 xor ebx, ebx ; exit code 0
 int 0x80 ; call the kernel

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

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

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

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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

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

```d
import std.stdio;


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

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

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

```nim
echo "Hello, Nim!"

```ocaml
print_endline "Hello, OCaml!"

```qml
import QtQuick 2.0


Text {
 text: "Hello, QML!"
 anchors.centerIn: parent
}

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

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

```crystal
puts "Hello, Crystal!"

```eiffel
class
 HELLO


create
 make


feature


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


end

```forth
." Hello, Forth!" cr

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


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

```applescript
display dialog "Hello, AppleScript!"

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

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

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

```tcl
puts "Hello, Tcl!"

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

```sed
sed 's/^/Hello, Sed!/'

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

```apl
'Hello, APL!'

```basic
10 PRINT "Hello, BASIC!"

```visualbasic
Module Module1


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


End Module

```delphi
program Hello;


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

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


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