Home



title: 'Reword this MDX' description: 'An example MDX file to be reworded.'

Reword this MDX

This is an example MDX file that needs to be reworded. The goal is to change the wording significantly while preserving the original meaning.

Example Section

Here's an example section with some text and a link.

const exampleCode = () => {
 console.log("Hello, world!");
};

Let's see if we can reword this effectively.



```python
def example_function():
 print("This is a Python example.")

And another paragraph to test the rephrasing.

```typescript
interface ExampleInterface {
 name: string;
 age: number;
}
```json
{
 "key": "value",
 "number": 123
}
```jsx
function ExampleComponent() {
 return (
 <div>
 <h1>Hello from React!</h1>
 </div>
 );
}
```bash
echo "This is a bash command."
```csharp
public class ExampleClass
{
 public string Name { get; set; }
}
```java
public class Example {
 public static void main(String[] args) {
 System.out.println("Hello, Java!");
 }
}
```go
package main


import "fmt"


func main() {
 fmt.Println("Hello, Go!")
}
```ruby
puts "Hello, Ruby!"
```kotlin
fun main() {
 println("Hello, Kotlin!")
}
```swift
print("Hello, Swift!")
```rust
fn main() {
 println!("Hello, Rust!");
}
```php
<?php
echo "Hello, PHP!";
?>
```sql
SELECT * FROM table_name;
```html
<!DOCTYPE html>
<html>
<head>
 <title>Example HTML</title>
</head>
<body>
 <h1>Hello, HTML!</h1>
</body>
</html>
```css
body {
 background-color: lightblue;
}
```lua
print("Hello, Lua!")
```r
print("Hello, R!")
```dart
void main() {
 print("Hello, Dart!");
}
```scala
object Main {
 def main(args: Array[String]): Unit = {
 println("Hello, Scala!")
 }
}
```perl
print "Hello, Perl!\n";
```powershell
Write-Host "Hello, PowerShell!"
```elixir
IO.puts "Hello, Elixir!"
```erlang
-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Hello, Erlang!\n").
```clojure
(println "Hello, Clojure!")
```coffeescript
console.log "Hello, CoffeeScript!"
```fsharp
printfn "Hello, F#!"
```haskell
main :: IO ()
main = putStrLn "Hello, Haskell!"
```julia
println("Hello, Julia!")
```objectivec
#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello, Objective-C!");
 }
 return 0;
}
```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:
 mov rax, 1
 mov rdi, 1
 mov rsi, msg
 mov rdx, 16
 syscall


 mov rax, 60
 xor rdi, rdi
 syscall
```fortran
program hello
 print *, "Hello, Fortran!"
end program hello
```lisp
(print "Hello, Lisp!")
```pascal
program Hello;
begin
 writeln('Hello, Pascal!');
end.
```prolog
hello :-
 write('Hello, Prolog!'), nl.
```scheme
(display "Hello, Scheme!")
(newline)
```tcl
puts "Hello, Tcl!"
```vbnet
Module Hello
 Sub Main()
 Console.WriteLine("Hello, VB.NET!")
 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, VHDL!" severity note;
 wait;
 end process;
end Behavioral;
```verilog
module hello;
 initial begin
 $display("Hello, Verilog!");
 $finish;
 end
endmodule
```applescript
display dialog "Hello, AppleScript!"
```batch
@echo off
echo Hello, Batch!
```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}
```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}
```cuda
#include <iostream>


__global__ void helloCUDA() {
 printf("Hello, CUDA from block %d, thread %d\n", blockIdx.x, threadIdx.x);
}


int main() {
 helloCUDA<<<1, 1>>>();
 cudaDeviceSynchronize();
 return 0;
}
```d
import std.stdio;


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


begin
 Writeln('Hello, Delphi!');
 Readln;
end.
```erl
-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Hello, Erlang!\n").
```elm
import Html exposing (text)


main =
 text "Hello, Elm!"
```groovy
println "Hello, Groovy!"
```j
echo 'Hello, J!'
```nim
echo "Hello, Nim!"
```ocaml
print_endline "Hello, OCaml!";
```pas
program Hello;
begin
 writeln('Hello, Pascal!');
end.
```pl
hello :-
 write('Hello, Prolog!'), nl.
```ps
(Hello World) =
```racket
#lang racket
(displayln "Hello, Racket!")
```rexx
say 'Hello, Rexx!'
```smalltalk
'Hello, Smalltalk!' displayNl.
```systemverilog
module hello;
 initial begin
 $display("Hello, SystemVerilog!");
 $finish;
 end
endmodule
```vala
int main() {
 print("Hello, Vala!\n");
 return 0;
}
```wolfram
Print["Hello, Wolfram Language!"]
```zig
const std = @import("std");


pub fn main() !void {
 const stdout = std.io.getStdOut().writer();
 try stdout.print("Hello, Zig!\n", .{});
}
```apl
'Hello, APL!'
```awk
BEGIN { print "Hello, Awk!" }
```ceylon
shared void run() {
 print("Hello, Ceylon!");
}
```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.
```forth
." Hello, Forth!" cr
bye
```fpc
program Hello;
begin
 writeln('Hello, Free Pascal!');
end.
```gdscript
print("Hello, GDScript!")
```idris
module Main


main : IO ()
main = putStrLn "Hello, Idris!"
```jakt
fun main() {
 print("Hello, Jakt!");
}
```k
/ "Hello, K!"
```lfe
(io:format "Hello, LFE!~n" [])
```m
main() {
 printf("Hello, M!\n");
}
```monkeyc
using Toybox.System as Sys;


function main() {
 Sys.println("Hello, Monkey C!");
}
```newlisp
(println "Hello, NewLisp!")
```octave
disp("Hello, Octave!")
```pony
actor Main
 new create(env: Env) =>
 env.out.print("Hello, Pony!")
```q
/ "Hello, Q!"
```reason
print_endline("Hello, Reason!");
```ring
see "Hello, Ring!"
```sibilant
(console.log "Hello, Sibilant!")
```squirrel
print("Hello, Squirrel!\n");
```terra
local ffi = require("ffi")


ffi.cdef[[
 int printf(const char *fmt, ...);
]]


ffi.C.printf("Hello, Terra!\n")
```unison
main = printLn "Hello, Unison!"
```v
fn main() {
 println("Hello, V!")
}
```wren
System.print("Hello, Wren!")
```xlisp
(print "Hello, XLisp!")
```yacc
%{
#include <stdio.h>
%}


%%
program:
 { printf("Hello, Yacc!\n"); }
 ;


%%
int main() {
 return yyparse();
}


int yyerror(char const* s) {
 fprintf(stderr, "%s\n", s);
 return 0;
}
```zsh
echo "Hello, Zsh!"
```agda
module Main where


open import IO


main : IO Unit
main = putStrLn "Hello, Agda!"
```cabal
name: hello
version: 0.1.0.0
synopsis: Simple hello world program
description: A basic example of a Cabal package.
category: Example
author: Your Name
maintainer: your.email@example.com
copyright: 2023 Your Name
license: MIT
license-file: LICENSE
build-type: Simple
cabal-version: >= 1.10


executable hello
 main-is: Main.hs
 build-depends: base >=4.7 && <5
 default-language: Haskell2010
```cmake
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)
add_executable(HelloWorld main.cpp)
```dockerfile
FROM ubuntu:latest


RUN apt-get update && apt-get install -y --no-install-recommends \
 ca-certificates


CMD ["echo", "Hello, Docker!"]
```git
[core]
 repositoryformatversion = 0
 filemode = true
 bare = false
 logallrefupdates = true
```graphql
type Query {
 hello: String
}


schema {
 query: Query
}
```ini
[section]
key = value
```latex
\documentclass{article}
\begin{document}
\title{Hello, LaTeX!}
\maketitle
Hello, LaTeX!
\end{document}
```makefile
hello:
 echo "Hello, Makefile!"
```markdown
# Hello, Markdown!


This is a simple Markdown file.
```nginx
events {}


http {
 server {
 listen 80;
 server_name localhost;


 location / {
 return 200 "Hello, Nginx!";
 }
 }
}
```properties
greeting=Hello, Properties!
```rproj
Version: 1.0


RestoreWorkspace: Default
SaveWorkspace: Default
AlwaysSaveHistory: Default


EnableCodeIndexing: Yes
UseSpacesForTab: True
NumSpacesForTab: 2
Encoding: UTF-8
```toml
title = "Hello, TOML!"
```txt
Hello, Text!
```xml
<?xml version="1.0"?>
<message>Hello, XML!</message>
```yaml
message: Hello, YAML!
```json5
{
 message: 'Hello, JSON5!'
}
```pug
doctype html
html
 head
 title Hello, Pug!
 body
 h1 Hello, Pug!
```haml
!!!
%html
 %head
 %title Hello, Haml!
 %body
 %h1 Hello, Haml!
```slim
doctype html
html
 head
 title Hello, Slim!
 body
 h1 Hello, Slim!
```stylus
body
 background-color: #eee
 h1
 color: navy
```less
@base-color: #eee;


body {
 background-color: @base-color;
}


h1 {
 color: navy;
}
```sass
$base-color: #eee


body
 background-color: $base-color


h1
 color: navy
```scss
$base-color: #eee;


body {
 background-color: $base-color;
}


h1 {
 color: navy;
}
```ejs
<!DOCTYPE html>
<html>
<head>
 <title>Hello, EJS!</title>
</head>
<body>
 <h1>Hello, EJS!</h1>
</body>
</html>
```handlebars
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Handlebars!</title>
</head>
<body>
 <h1>Hello, Handlebars!</h1>
</body>
</html>
```liquid
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Liquid!</title>
</head>
<body>
 <h1>Hello, Liquid!</h1>
</body>
</html>
```mustache
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Mustache!</title>
</head>
<body>
 <h1>Hello, Mustache!</h1>
</body>
</html>
```nunjucks
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Nunjucks!</title>
</head>
<body>
 <h1>Hello, Nunjucks!</h1>
</body>
</html>
```dust
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Dust!</title>
</head>
<body>
 <h1>Hello, Dust!</h1>
</body>
</html>
```art-template
<!DOCTYPE html>
<html>
<head>
 <title>Hello, art-template!</title>
</head>
<body>
 <h1>Hello, art-template!</h1>
</body>
</html>
```velocity
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Velocity!</title>
</head>
<body>
 <h1>Hello, Velocity!</h1>
</body>
</html>
```freemarker
<!DOCTYPE html>
<html>
<head>
 <title>Hello, FreeMarker!</title>
</head>
<body>
 <h1>Hello, FreeMarker!</h1>
</body>
</html>
```thymeleaf
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <title>Hello, Thymeleaf!</title>
</head>
<body>
 <h1 th:text="'Hello, Thymeleaf!'"></h1>
</body>
</html>
```jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
 <title>Hello, JSP!</title>
</head>
<body>
 <h1>Hello, JSP!</h1>
</body>
</html>
```asp
<%@ Language=VBScript %>
<!DOCTYPE html>
<html>
<head>
 <title>Hello, ASP!</title>
</head>
<body>
 <h1>Hello, ASP!</h1>
</body>
</html>
```aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication1.Default" %>


<!DOCTYPE html>


<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
 <title>Hello, ASP.NET!</title>
</head>
<body>
 <form id="form1" runat="server">
 <div>
 <h1>Hello, ASP.NET!</h1>
 </div>
 </form>
</body>
</html>
```cfm
<!DOCTYPE html>
<html>
<head>
 <title>Hello, ColdFusion!</title>
</head>
<body>
 <h1>Hello, ColdFusion!</h1>
</body>
</html>
```erb
<!DOCTYPE html>
<html>
<head>
 <title>Hello, ERB!</title>
</head>
<body>
 <h1>Hello, ERB!</h1>
</body>
</html>
```cshtml
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Razor!</title>
</head>
<body>
 <h1>Hello, Razor!</h1>
</body>
</html>
```twig
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Twig!</title>
</head>
<body>
 <h1>Hello, Twig!</h1>
</body>
</html>
```blade
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Blade!</title>
</head>
<body>
 <h1>Hello, Blade!</h1>
</body>
</html>
```soy
{namespace example}


/** Template for hello world. */
{template .helloWorld}
 <!DOCTYPE html>
 <html>
 <head>
 <title>Hello, Soy!</title>
 </head>
 <body>
 <h1>Hello, Soy!</h1>
 </body>
 </html>
{/template}
```vue
<template>
 <div>
 <h1>Hello, Vue!</h1>
 </div>
</template>


<script>
export default {
 name: 'HelloWorld'
}
</script>
```svelte
<script>
 let name = 'world';
</script>


<h1>Hello {name}!</h1>
```riot
<hello>
 <h1>Hello, Riot!</h1>
</hello>
```mithril
var Hello = {
 view: function() {
 return m("h1", "Hello, Mithril!")
 }
}


m.mount(document.body, Hello)
```inferno
import { render } from 'inferno';
import { createElement } from 'inferno-create-element';


const Hello = () => createElement('h1', null, 'Hello, Inferno!');


render(createElement(Hello), document.body);
```preact
import { h, render } from 'preact';


const Hello = () => <h1>Hello, Preact!</h1>;


render(<Hello>, document.body);
```stencil
import { Component, h } from '@stencil/core';


@Component({
 tag: 'my-hello',
 styleUrl: 'my-hello.css',
 shadow: true
})
export class MyHello {
 render() {
 return (
 <h1>Hello, Stencil!</h1>
 );
 }
}
```solid
import { render } from 'solid-js/web';
import { createSignal } from 'solid-js';


function Hello() {
 return <h1>Hello, Solid!</h1>;
}


render(() => <Hello>, document.body);
```marko
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Marko!</title>
</head>
<body>
 <h1>Hello, Marko!</h1>
</body>
</html>
```imba
tag Hello
 def render
 <h1> Hello, Imba!
```stimulus
import { Controller } from "@hotwired/stimulus"


export default class extends Controller {
 connect() {
 console.log("Hello, Stimulus!")
 }
}
```alpine
<div x-data="{ message: 'Hello, Alpine!' }">
 <h1 x-text="message"></h1>
</div>
```htmx
<!DOCTYPE html>
<html>
<head>
 <title>Hello, HTMX!</title>
</head>
<body>
 <h1>Hello, HTMX!</h1>
</body>
</html>
```rescript
let message = "Hello, ReScript!"
Js.log(message)
```bucklescript
let message = "Hello, BuckleScript!"
Js.log(message)
```melange
let message = "Hello, Melange!"
Js.log(message)
```dhall
let message = "Hello, Dhall!" in
message
```nickel
{ message = "Hello, Nickel!" }
```purescript
module Main where


import Effect (Effect)
import Effect.Console (log)


main :: Effect Unit
main = log "Hello, PureScript!"
```roc
app "hello-world"
packages { base: "https://github.com/roc-lang/roc-basic-cli/releases/download/0.1.0/roc_basic_cli-0.1.0.tar.br" }
imports []
provides [main]


main =
 "Hello, Roc!"
```teal
local message: string = "Hello, Teal!"
print(message)
```yara
rule Hello {
 strings:
 $message = "Hello, YARA!"
 condition:
 $message
}
```ada
with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello, Ada!");
end Hello;
```agda
module Main where


open import IO


main : IO Unit
main = putStrLn "Hello, Agda!"
```apl
'Hello, APL!'
```awk
BEGIN { print "Hello, Awk!" }
```cabal
name: hello
version: 0.1.0.0
synopsis: Simple hello world program
description: A basic example of a Cabal package.
category: Example
author: Your Name
maintainer: your.email@example.com
copyright: 2023 Your Name
license: MIT
license-file: LICENSE
build-type: Simple
cabal-version: >= 1.10


executable hello
 main-is: Main.hs
 build-depends: base >=4.7 && <5
 default-language: Haskell2010
```cmake
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)
add_executable(HelloWorld main.cpp)
```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.
```coffeescript
console.log "Hello, CoffeeScript!"
```cuda
#include <iostream>


__global__ void helloCUDA() {
 printf("Hello, CUDA from block %d, thread %d\n", blockIdx.x, threadIdx.x);
}


int main() {
 helloCUDA<<<1, 1>>>();
 cudaDeviceSynchronize();
 return 0;
}
```d
import std.stdio;


void main() {
 writeln("Hello, D!");
}
```dart
void main() {
 print("Hello, Dart!");
}
```delphi
program Hello;


begin
 Writeln('Hello, Delphi!');
 Readln;
end.
```dhall
let message = "Hello, Dhall!" in
message
```dockerfile
FROM ubuntu:latest


RUN apt-get update && apt-get install -y --no-install-recommends \
 ca-certificates


CMD ["echo", "Hello, Docker!"]
```dust
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Dust!</title>
</head>
<body>
 <h1>Hello, Dust!</h1>
</body>
</html>
```ejs
<!DOCTYPE html>
<html>
<head>
 <title>Hello, EJS!</title>
</head>
<body>
 <h1>Hello, EJS!</h1>
</body>
</html>
```elixir
IO.puts "Hello, Elixir!"
```elm
import Html exposing (text)


main =
 text "Hello, Elm!"
```erlang
-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Hello, Erlang!\n").
```fsharp
printfn "Hello, F#!"
```fortran
program hello
 print *, "Hello, Fortran!"
end program hello
```freemarker
<!DOCTYPE html>
<html>
<head>
 <title>Hello, FreeMarker!</title>
</head>
<body>
 <h1>Hello, FreeMarker!</h1>
</body>
</html>
```gdscript
print("Hello, GDScript!")
```git
[core]
 repositoryformatversion = 0
 filemode = true
 bare = false
 logallrefupdates = true
```go
package main


import "fmt"


func main() {
 fmt.Println("Hello, Go!")
}
```groovy
println "Hello, Groovy!"
```graphql
type Query {
 hello: String
}


schema {
 query: Query
}
```haml
!!!
%html
 %head
 %title Hello, Haml!
 %body
 %h1 Hello, Haml!
```handlebars
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Handlebars!</title>
</head>
<body>
 <h1>Hello, Handlebars!</h1>
</body>
</html>
```haskell
main :: IO ()
main = putStrLn "Hello, Haskell!"
```htmx
<!DOCTYPE html>
<html>
<head>
 <title>Hello, HTMX!</title>
</head>
<body>
 <h1>Hello, HTMX!</h1>
</body>
</html>
```idris
module Main


main : IO ()
main = putStrLn "Hello, Idris!"
```imba
tag Hello
 def render
 <h1> Hello, Imba!
```ini
[section]
key = value
```inferno
import { render } from 'inferno';
import { createElement } from 'inferno-create-element';


const Hello = () => createElement('h1', null, 'Hello, Inferno!');


render(createElement(Hello), document.body);
```j
echo 'Hello, J!'
```jakt
fun main() {
 print("Hello, Jakt!");
}
```java
public class Example {
 public static void main(String[] args) {
 System.out.println("Hello, Java!");
 }
}
```javascript
const exampleCode = () => {
 console.log("Hello, world!");
};
```json
{
 "key": "value",
 "number": 123
}
```json5
{
 message: 'Hello, JSON5!'
}
```jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
 <title>Hello, JSP!</title>
</head>
<body>
 <h1>Hello, JSP!</h1>
</body>
</html>
```julia
println("Hello, Julia!")
```k
/ "Hello, K!"
```kotlin
fun main() {
 println("Hello, Kotlin!")
}
```latex
\documentclass{article}
\begin{document}
\title{Hello, LaTeX!}
\maketitle
Hello, LaTeX!
\end{document}
```less
@base-color: #eee;


body {
 background-color: @base-color;
}


h1 {
 color: navy;
}
```lfe
(io:format "Hello, LFE!~n" [])
```liquid
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Liquid!</title>
</head>
<body>
 <h1>Hello, Liquid!</h1>
</body>
</html>
```lisp
(print "Hello, Lisp!")
```lua
print("Hello, Lua!")
```m
main() {
 printf("Hello, M!\n");
}
```makefile
hello:
 echo "Hello, Makefile!"
```marko
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Marko!</title>
</head>
<body>
 <h1>Hello, Marko!</h1>
</body>
</html>
```markdown
# Hello, Markdown!


This is a simple Markdown file.
```melange
let message = "Hello, Melange!"
Js.log(message)
```mithril
var Hello = {
 view: function() {
 return m("h1", "Hello, Mithril!")
 }
}


m.mount(document.body, Hello)
```monkeyc
using Toybox.System as Sys;


function main() {
 Sys.println("Hello, Monkey C!");
}
```mustache
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Mustache!</title>
</head>
<body>
 <h1>Hello, Mustache!</h1>
</body>
</html>
```newlisp
(println "Hello, NewLisp!")
```nginx
events {}


http {
 server {
 listen 80;
 server_name localhost;


 location / {
 return 200 "Hello, Nginx!";
 }
 }
}
```nickel
{ message = "Hello, Nickel!" }
```nim
echo "Hello, Nim!"
```nunjucks
<!DOCTYPE html>
<html>
<head>
 <title>Hello, Nunjucks!</title>
</head>
<body>
 <h1>Hello, Nunjucks!</h1>
</body>
</html>
```objectivec
#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello, Objective-C!");
 }
 return 0;
}
```ocaml
print_endline "Hello, OCaml!";
```octave
disp("Hello, Octave!")
```pas
program Hello;
begin
 writeln('Hello, Pascal!');
end.
```pascal
program Hello;
begin
 writeln('Hello, Pascal!');
end.
```perl
print "Hello, Perl!\n";
```php
<?php
echo "Hello, PHP!";
?>
```pl
hello :-
 write('Hello, Prolog!'), nl.

<AppearanceSection></AppearanceSection>