DEV Community

Cover image for JLScript: A Brazilian Programming Language With Portuguese and English Syntax
JLScript
JLScript

Posted on Edited on

JLScript: A Brazilian Programming Language With Portuguese and English Syntax

JLScript: A Brazilian Programming Language With Portuguese and English Syntax

Programming should be understandable before it becomes complicated.

JLScript is a Brazilian programming language created by Lucas Aguiel and currently under active development.

The project focuses on readable syntax, beginner-friendly programming, Portuguese and English language constructs, built-in modules, command-line tooling, libraries, API development, and an expanding ecosystem.

JLScript uses the .jls file extension.

Official portal:

https://blog-jlscript.netlify.app/


Important: JLScript is NOT open source

Before anything else, one important clarification:

JLScript is not an open-source programming language.

The current core implementation of JLScript is closed-source.

The internal source code of the language, runtime, compiler components, and other private implementation details are not distributed as an open-source project.

Public documentation may describe:

  • JLScript syntax
  • language behavior
  • public commands
  • libraries
  • modules
  • examples
  • tutorials
  • ecosystem tools

But this does not mean that the JLScript core source code is open source.

Developers can still create their own .jls projects and choose their own licenses for those projects.

Community libraries may also use their own licenses independently from the JLScript core.

Older JLScript pages or posts may contain outdated references describing the project as open source. Those descriptions no longer represent the current project policy.


What is JLScript?

JLScript is designed around a simple idea:

code should be readable even when you are still learning programming.

Instead of forcing beginners to immediately become familiar with English-only keywords, JLScript supports several programming constructions in Portuguese while also keeping English alternatives.

For example:

va nome = "Lucas"

se (nome == "Lucas") {
    mostrar("Olá, Lucas!")
}
Enter fullscreen mode Exit fullscreen mode

The same general programming style can also use English constructs:

let nome = "Lucas"

if (nome == "Lucas") {
    mostrar("Hello, Lucas!")
}
Enter fullscreen mode Exit fullscreen mode

This allows JLScript to maintain its Brazilian identity without isolating developers from programming terminology commonly used internationally.


Variables

JLScript supports multiple variable declarations.

va nome = "JLScript"
let versao = "3.2.0"
ins ativo = true
Enter fullscreen mode Exit fullscreen mode

Values can include strings, numbers, booleans, lists, objects, and null values.

va linguagem = "JLScript"
va ano = 2026
va ativo = true
va vazio = null
Enter fullscreen mode Exit fullscreen mode

Basic types and conversions

JLScript includes common type conversion functions.

va numero = int("42")
va decimal = float("10.5")
va texto = str(100)
va estado = bool(true)
Enter fullscreen mode Exit fullscreen mode

Common types include:

int
float
str
bool
null
Enter fullscreen mode Exit fullscreen mode

Output

The most recognizable JLScript output function is mostrar().

mostrar("Olá, mundo!")
Enter fullscreen mode Exit fullscreen mode

You can also work with values:

va linguagem = "JLScript"

mostrar(linguagem)
Enter fullscreen mode Exit fullscreen mode

And expressions:

va a = 10
va b = 20

mostrar(a + b)
Enter fullscreen mode Exit fullscreen mode

Conditions

JLScript supports conditional execution using Portuguese syntax:

va idade = 18

se (idade >= 18) {
    mostrar("Maior de idade")
} senao {
    mostrar("Menor de idade")
}
Enter fullscreen mode Exit fullscreen mode

And English syntax:

let idade = 18

if (idade >= 18) {
    mostrar("Adult")
} else {
    mostrar("Minor")
}
Enter fullscreen mode Exit fullscreen mode

Conditions can use comparison and logical operators.

va idade = 20
va possuiConta = true

se (idade >= 18 && possuiConta == true) {
    mostrar("Acesso permitido")
}
Enter fullscreen mode Exit fullscreen mode

JLScript supports operators such as:

==
!=
>
<
>=
<=
&&
||
!
Enter fullscreen mode Exit fullscreen mode

Functions

Functions can be created using func.

func saudacao(nome) {
    mostrar("Olá, " + nome)
}
Enter fullscreen mode Exit fullscreen mode

Then called normally:

saudacao("Lucas")
Enter fullscreen mode Exit fullscreen mode

Functions can return values using retorne.

func somar(a, b) {
    retorne a + b
}

va resultado = somar(10, 20)

mostrar(resultado)
Enter fullscreen mode Exit fullscreen mode

Short function syntax

JLScript also supports a shorter function declaration style.

somar(a, b) {
    retorne a + b
}
Enter fullscreen mode Exit fullscreen mode

Usage:

va resultado = somar(5, 7)

mostrar(resultado)
Enter fullscreen mode Exit fullscreen mode

Default parameters

Functions can have default values.

func apresentar(nome = "Visitante") {
    mostrar("Olá, " + nome)
}

apresentar()
apresentar("Lucas")
Enter fullscreen mode Exit fullscreen mode

Named arguments

JLScript also supports named arguments.

func usuario(nome, idade) {
    mostrar(nome)
    mostrar(idade)
}

usuario(nome = "Lucas", idade = 19)
Enter fullscreen mode Exit fullscreen mode

Named arguments can also use :.

usuario(nome: "Lucas", idade: 19)
Enter fullscreen mode Exit fullscreen mode

Anonymous functions

Functions can also be used anonymously.

va soma = func(a, b) {
    retorne a + b
}

mostrar(soma(10, 5))
Enter fullscreen mode Exit fullscreen mode

While loops

Portuguese:

va contador = 1

enquanto (contador <= 5) {
    mostrar(contador)

    contador++
}
Enter fullscreen mode Exit fullscreen mode

English:

let contador = 1

while (contador <= 5) {
    mostrar(contador)

    contador++
}
Enter fullscreen mode Exit fullscreen mode

For loops

JLScript supports for and its Portuguese equivalent para.

para (va i = 0; i < 5; i++) {
    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

English form:

for (let i = 0; i < 5; i++) {
    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

Break and continue

Portuguese:

para (va i = 0; i < 10; i++) {

    se (i == 5) {
        pare
    }

    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

JLScript also supports:

continuar
Enter fullscreen mode Exit fullscreen mode

English equivalents include:

break
continue
Enter fullscreen mode Exit fullscreen mode

Switch

JLScript supports switch-style control flow.

va opcao = 2

escolha (opcao) {

    caso 1 {
        mostrar("Opção 1")
    }

    caso 2 {
        mostrar("Opção 2")
    }

    padrao {
        mostrar("Outra opção")
    }
}
Enter fullscreen mode Exit fullscreen mode

English syntax is also available:

switch (opcao) {

    case 1 {
        mostrar("Option 1")
    }

    case 2 {
        mostrar("Option 2")
    }

    default {
        mostrar("Another option")
    }
}
Enter fullscreen mode Exit fullscreen mode

Error handling

JLScript supports structured error handling.

Portuguese:

tente {

    mostrar("Executando...")

} capture (erro) {

    mostrar("Erro:")
    mostrar(erro)

} finalmente {

    mostrar("Finalizado")
}
Enter fullscreen mode Exit fullscreen mode

English:

try {

    mostrar("Running...")

} catch (erro) {

    mostrar(erro)

} finally {

    mostrar("Finished")
}
Enter fullscreen mode Exit fullscreen mode

Lists

JLScript supports lists.

va linguagens = [
    "JLScript",
    "JavaScript",
    "Python"
]
Enter fullscreen mode Exit fullscreen mode

Values can be accessed and manipulated through language functions and module APIs.

Lists can contain multiple value types.

va dados = [
    "Lucas",
    19,
    true
]
Enter fullscreen mode Exit fullscreen mode

Objects

JLScript also supports object-style structures.

va usuario = {
    nome: "Lucas",
    linguagem: "JLScript",
    ativo: true
}
Enter fullscreen mode Exit fullscreen mode

Member access can be used to work with object properties.

mostrar(usuario.nome)
mostrar(usuario.linguagem)
Enter fullscreen mode Exit fullscreen mode

Imports

Modules can be imported using import.

import #math
Enter fullscreen mode Exit fullscreen mode

Multiple modules can also be imported:

import [
    #math,
    #json,
    #file
]
Enter fullscreen mode Exit fullscreen mode

Module aliases

Modules can receive aliases.

import #math como matematica
Enter fullscreen mode Exit fullscreen mode

This helps keep larger projects organized.


JLScript modules

JLScript's ecosystem includes modules for different types of development.

Examples include:

import #api
import #math
import #json
import #file
import #system
import #database
import #crypto
import #process
import #net
import #test
import #cli
import #image
import #audio
import #ui
import #style
Enter fullscreen mode Exit fullscreen mode

Other modules are also being developed as the ecosystem expands.


Math

The #math module provides mathematical functionality.

import #math
Enter fullscreen mode Exit fullscreen mode

Examples of available mathematical concepts include:

math.raiz(25)
math.absoluto(-10)
math.arredondar(10.8)
math.teto(10.1)
math.piso(10.9)
Enter fullscreen mode Exit fullscreen mode

The module also includes trigonometric functions, logarithms, statistics, and mathematical constants.


JSON

JLScript includes JSON-related functionality through:

import #json
Enter fullscreen mode Exit fullscreen mode

This is useful for applications that communicate with web APIs, configuration files, and structured data.


Files

File-related functionality is available through:

import #file
Enter fullscreen mode Exit fullscreen mode

The module is designed for working with files and filesystem operations inside JLScript applications.


Database support

JLScript includes database functionality through:

import #database
Enter fullscreen mode Exit fullscreen mode

Current database tooling includes SQLite-oriented functionality.

This allows JLScript applications to work with local structured data without requiring an external database server for every project.


Cryptography

Cryptographic utilities are available through:

import #crypto
Enter fullscreen mode Exit fullscreen mode

The module includes functionality related to concepts such as:

UUID
random values
Base64
HMAC
AES
Enter fullscreen mode Exit fullscreen mode

Processes

JLScript can interact with processes through:

import #process
Enter fullscreen mode Exit fullscreen mode

Public process functionality includes operations related to:

executing processes
starting processes
listing processes
checking whether a process exists
Enter fullscreen mode Exit fullscreen mode

Network functionality

Networking-related development is represented by:

import #net
Enter fullscreen mode Exit fullscreen mode

This is part of JLScript's goal of growing beyond purely educational scripts.


API development

JLScript includes an API-oriented module:

import #api
Enter fullscreen mode Exit fullscreen mode

The module includes functionality for creating servers and working with HTTP requests.

Server-related APIs include concepts such as:

servidor
criarApi
criarServidor
server
create
Enter fullscreen mode Exit fullscreen mode

Client-side HTTP functionality includes operations related to:

GET
POST
PUT
PATCH
DELETE
JSON requests
Enter fullscreen mode Exit fullscreen mode

This means JLScript is being designed not only to teach basic syntax, but also to support backend and web development scenarios.


UI development

JLScript also has UI-oriented modules.

import #ui
import #style
Enter fullscreen mode Exit fullscreen mode

The #ui module contains concepts such as:

janela
div
section
main
header
footer
nav
h1
p
span
button
input
form
table
card
row
column
Enter fullscreen mode Exit fullscreen mode

The goal is to provide a JLScript-native way to describe interfaces.


Styling

The #style module complements #ui.

import #style
Enter fullscreen mode Exit fullscreen mode

It includes styling-oriented functionality and selector concepts such as:

class
classe
id
type
tipo
Enter fullscreen mode Exit fullscreen mode

JLScript UI is still evolving as part of the broader ecosystem.


Time and durations

JLScript includes readable duration syntax.

Examples:

esperar(500ms)
Enter fullscreen mode Exit fullscreen mode
esperar(2segundos)
Enter fullscreen mode Exit fullscreen mode
esperar(1minuto)
Enter fullscreen mode Exit fullscreen mode

Duration units include concepts such as:

ms
segundo
segundos
minuto
minutos
hora
horas
dia
dias
Enter fullscreen mode Exit fullscreen mode

English variants are also supported.


Time utilities

JLScript provides time-related global functionality.

Examples include concepts such as:

tempo.agora()
Enter fullscreen mode Exit fullscreen mode

and English equivalents:

time.now()
Enter fullscreen mode Exit fullscreen mode

Other time APIs include scheduled and repeated execution concepts such as:

tempo.depois
tempo.cada
time.after
time.every
Enter fullscreen mode Exit fullscreen mode

User interaction

JLScript includes built-in functions for terminal interaction.

va nome = ler("Digite seu nome: ")

mostrar(nome)
Enter fullscreen mode Exit fullscreen mode

Confirmation functionality is also available through:

confirmar("Deseja continuar?")
Enter fullscreen mode Exit fullscreen mode

or:

confirm("Continue?")
Enter fullscreen mode Exit fullscreen mode

Terminal utilities

JLScript includes several useful terminal-oriented functions.

Examples include:

limpar()
Enter fullscreen mode Exit fullscreen mode
titulo("Meu aplicativo")
Enter fullscreen mode Exit fullscreen mode
mostrarAviso("Atenção")
Enter fullscreen mode Exit fullscreen mode
mostrarErro("Algo deu errado")
Enter fullscreen mode Exit fullscreen mode
mostrarSucesso("Operação concluída")
Enter fullscreen mode Exit fullscreen mode

These APIs help developers build more complete command-line applications.


.jls files

JLScript source files use the .jls extension.

Example:

main.jls
Enter fullscreen mode Exit fullscreen mode

A simple program could look like:

va linguagem = "JLScript"

func apresentar(nome) {
    mostrar("Bem-vindo ao " + nome)
}

apresentar(linguagem)
Enter fullscreen mode Exit fullscreen mode

JLScript CLI

JLScript includes a command-line interface for working with projects and source files.

Examples of commands include:

jls run
Enter fullscreen mode Exit fullscreen mode

Run a JLScript project.

jls build
Enter fullscreen mode Exit fullscreen mode

Build a project.

jls compile
Enter fullscreen mode Exit fullscreen mode

Compile JLScript code.

jls test
Enter fullscreen mode Exit fullscreen mode

Run tests.

jls fmt
Enter fullscreen mode Exit fullscreen mode

Format JLScript source code.

jls lint
Enter fullscreen mode Exit fullscreen mode

Analyze source code.

jls doctor
Enter fullscreen mode Exit fullscreen mode

Check the development environment.

jls dev
Enter fullscreen mode Exit fullscreen mode

Start development workflows.

Other CLI commands include:

preview
targets
clean
verify-bytecode
update
repl
config
new
create
init
fix
ai
language
linguagem
selfhost
Enter fullscreen mode Exit fullscreen mode

Compilation

JLScript source code uses:

.jls
Enter fullscreen mode Exit fullscreen mode

The compiler can generate:

.jlb
Enter fullscreen mode Exit fullscreen mode

Bytecode verification tooling is also part of the CLI.


Visual Studio Code integration

JLScript has tooling designed to improve development inside Visual Studio Code.

The project includes concepts such as:

  • syntax highlighting
  • autocomplete
  • snippets
  • hover information
  • run actions
  • JLScript-specific editing support

The goal is to make .jls files feel like first-class programming files inside the editor.


JLShell

The JLScript ecosystem also includes JLShell.

JLShell is focused on terminal-based interaction with JLScript tools and development workflows.

It is part of the broader plan to make JLScript more than only a language parser or runtime.


JLS AI

Another project in the ecosystem is JLS AI.

JLS AI is being developed as an assistant focused on JLScript development.

Its goals include helping with tasks such as:

  • understanding .jls code
  • assisting programmers
  • providing code suggestions
  • helping with JLScript projects
  • terminal-based assistance
  • development workflows

The project is intended to integrate with the JLScript ecosystem rather than replace the language itself.


Portuguese and English

One of the main characteristics of JLScript is its bilingual programming model.

For example:

se (ativo) {
    mostrar("Ativo")
} senao {
    mostrar("Inativo")
}
Enter fullscreen mode Exit fullscreen mode

and:

if (ativo) {
    mostrar("Active")
} else {
    mostrar("Inactive")
}
Enter fullscreen mode Exit fullscreen mode

Loops:

enquanto (ativo) {
    mostrar("Executando")
}
Enter fullscreen mode Exit fullscreen mode

or:

while (ativo) {
    mostrar("Running")
}
Enter fullscreen mode Exit fullscreen mode

Control flow:

se       / if
senao    / else
enquanto / while
para     / for
escolha  / switch
caso     / case
padrao   / default
pare     / break
continuar / continue
tente    / try
capture  / catch
finalmente / finally
Enter fullscreen mode Exit fullscreen mode

This is not intended to hide traditional programming concepts.

Instead, it provides another way to learn and express them.


A more complete example

Here is a larger JLScript example combining variables, functions, conditions, loops, and objects:

va usuario = {
    nome: "Lucas",
    idade: 19,
    linguagem: "JLScript"
}

func apresentar(usuario) {

    mostrar("Nome: " + usuario.nome)
    mostrar("Linguagem: " + usuario.linguagem)

    se (usuario.idade >= 18) {
        mostrar("Usuário adulto")
    } senao {
        mostrar("Usuário menor de idade")
    }
}

apresentar(usuario)

para (va i = 1; i <= 5; i++) {
    mostrar("Contagem: " + str(i))
}
Enter fullscreen mode Exit fullscreen mode

What JLScript is trying to become

JLScript started as an experiment around a simple question:

What would happen if I created my own programming language?

Over time, that experiment grew into a larger project involving:

  • language syntax
  • execution
  • modules
  • libraries
  • CLI tools
  • editor integration
  • API development
  • UI experiments
  • documentation
  • developer tooling
  • artificial intelligence integration
  • an ecosystem around .jls

The objective is not simply to create alternative keywords for another language.

The long-term goal is to build a language with its own identity, tooling, ecosystem, and development experience.


The origin of the name JLScript

The name JLScript has a personal origin.

J represents Joicy Costa.

L represents Lucas Aguiel.

Script represents the programming language itself.

The name became part of the project's identity as the language evolved.


Who created JLScript?

JLScript was created by Lucas Aguiel, a Brazilian developer interested in programming languages, development tools, automation, artificial intelligence, and software creation.

The project began from curiosity about how programming languages work internally and gradually evolved into a complete language ecosystem.


Is JLScript finished?

No.

JLScript is still under active development.

Features, libraries, tools, documentation, compatibility, and the language ecosystem continue to evolve.

That means syntax and APIs can still receive improvements as the project matures.


Is JLScript open source?

No.

To make this completely clear:

JLScript is currently a closed-source project.

Public documentation and examples are available so developers can learn and use the language.

That does not provide access to the private implementation of the JLScript core.

Projects written by users in JLScript remain separate from the licensing of the language itself.


Learn JLScript

The current JLScript portal contains documentation, syntax references, projects, libraries, history, and ecosystem information.

Official JLScript portal:

https://blog-jlscript.netlify.app/

Learn JLScript:

https://blog-jlscript.netlify.app/aprender

Syntax:

https://blog-jlscript.netlify.app/sintaxe

Libraries:

https://blog-jlscript.netlify.app/bibliotecas

Projects:

https://blog-jlscript.netlify.app/projetos

CLI:

https://blog-jlscript.netlify.app/cli

Ecosystem:

https://blog-jlscript.netlify.app/ecossistema

History:

https://blog-jlscript.netlify.app/historia

Resources:

https://blog-jlscript.netlify.app/recursos


GitHub

Public JLScript resources can also be found on GitHub:

https://github.com/eohlczinn/JLScript

The existence of a public GitHub repository should not be interpreted as meaning that the complete JLScript core implementation is open source.

Public repositories may contain documentation, examples, public resources, tools, or project-related material.


Final thoughts

JLScript is an attempt to explore what programming can look like when readability, Portuguese-speaking developers, tooling, and language identity are treated as first-class concerns.

It supports familiar programming concepts while allowing code such as:

va mensagem = "JLScript: código que fala a sua língua."

mostrar(mensagem)
Enter fullscreen mode Exit fullscreen mode

The language is still growing.

So are its libraries.

So are its tools.

And so is its ecosystem.

JLScript: code that speaks your language.

https://blog-jlscript.netlify.app/

Top comments (0)