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!")
}
The same general programming style can also use English constructs:
let nome = "Lucas"
if (nome == "Lucas") {
mostrar("Hello, Lucas!")
}
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
Values can include strings, numbers, booleans, lists, objects, and null values.
va linguagem = "JLScript"
va ano = 2026
va ativo = true
va vazio = null
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)
Common types include:
int
float
str
bool
null
Output
The most recognizable JLScript output function is mostrar().
mostrar("Olá, mundo!")
You can also work with values:
va linguagem = "JLScript"
mostrar(linguagem)
And expressions:
va a = 10
va b = 20
mostrar(a + b)
Conditions
JLScript supports conditional execution using Portuguese syntax:
va idade = 18
se (idade >= 18) {
mostrar("Maior de idade")
} senao {
mostrar("Menor de idade")
}
And English syntax:
let idade = 18
if (idade >= 18) {
mostrar("Adult")
} else {
mostrar("Minor")
}
Conditions can use comparison and logical operators.
va idade = 20
va possuiConta = true
se (idade >= 18 && possuiConta == true) {
mostrar("Acesso permitido")
}
JLScript supports operators such as:
==
!=
>
<
>=
<=
&&
||
!
Functions
Functions can be created using func.
func saudacao(nome) {
mostrar("Olá, " + nome)
}
Then called normally:
saudacao("Lucas")
Functions can return values using retorne.
func somar(a, b) {
retorne a + b
}
va resultado = somar(10, 20)
mostrar(resultado)
Short function syntax
JLScript also supports a shorter function declaration style.
somar(a, b) {
retorne a + b
}
Usage:
va resultado = somar(5, 7)
mostrar(resultado)
Default parameters
Functions can have default values.
func apresentar(nome = "Visitante") {
mostrar("Olá, " + nome)
}
apresentar()
apresentar("Lucas")
Named arguments
JLScript also supports named arguments.
func usuario(nome, idade) {
mostrar(nome)
mostrar(idade)
}
usuario(nome = "Lucas", idade = 19)
Named arguments can also use :.
usuario(nome: "Lucas", idade: 19)
Anonymous functions
Functions can also be used anonymously.
va soma = func(a, b) {
retorne a + b
}
mostrar(soma(10, 5))
While loops
Portuguese:
va contador = 1
enquanto (contador <= 5) {
mostrar(contador)
contador++
}
English:
let contador = 1
while (contador <= 5) {
mostrar(contador)
contador++
}
For loops
JLScript supports for and its Portuguese equivalent para.
para (va i = 0; i < 5; i++) {
mostrar(i)
}
English form:
for (let i = 0; i < 5; i++) {
mostrar(i)
}
Break and continue
Portuguese:
para (va i = 0; i < 10; i++) {
se (i == 5) {
pare
}
mostrar(i)
}
JLScript also supports:
continuar
English equivalents include:
break
continue
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")
}
}
English syntax is also available:
switch (opcao) {
case 1 {
mostrar("Option 1")
}
case 2 {
mostrar("Option 2")
}
default {
mostrar("Another option")
}
}
Error handling
JLScript supports structured error handling.
Portuguese:
tente {
mostrar("Executando...")
} capture (erro) {
mostrar("Erro:")
mostrar(erro)
} finalmente {
mostrar("Finalizado")
}
English:
try {
mostrar("Running...")
} catch (erro) {
mostrar(erro)
} finally {
mostrar("Finished")
}
Lists
JLScript supports lists.
va linguagens = [
"JLScript",
"JavaScript",
"Python"
]
Values can be accessed and manipulated through language functions and module APIs.
Lists can contain multiple value types.
va dados = [
"Lucas",
19,
true
]
Objects
JLScript also supports object-style structures.
va usuario = {
nome: "Lucas",
linguagem: "JLScript",
ativo: true
}
Member access can be used to work with object properties.
mostrar(usuario.nome)
mostrar(usuario.linguagem)
Imports
Modules can be imported using import.
import #math
Multiple modules can also be imported:
import [
#math,
#json,
#file
]
Module aliases
Modules can receive aliases.
import #math como matematica
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
Other modules are also being developed as the ecosystem expands.
Math
The #math module provides mathematical functionality.
import #math
Examples of available mathematical concepts include:
math.raiz(25)
math.absoluto(-10)
math.arredondar(10.8)
math.teto(10.1)
math.piso(10.9)
The module also includes trigonometric functions, logarithms, statistics, and mathematical constants.
JSON
JLScript includes JSON-related functionality through:
import #json
This is useful for applications that communicate with web APIs, configuration files, and structured data.
Files
File-related functionality is available through:
import #file
The module is designed for working with files and filesystem operations inside JLScript applications.
Database support
JLScript includes database functionality through:
import #database
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
The module includes functionality related to concepts such as:
UUID
random values
Base64
HMAC
AES
Processes
JLScript can interact with processes through:
import #process
Public process functionality includes operations related to:
executing processes
starting processes
listing processes
checking whether a process exists
Network functionality
Networking-related development is represented by:
import #net
This is part of JLScript's goal of growing beyond purely educational scripts.
API development
JLScript includes an API-oriented module:
import #api
The module includes functionality for creating servers and working with HTTP requests.
Server-related APIs include concepts such as:
servidor
criarApi
criarServidor
server
create
Client-side HTTP functionality includes operations related to:
GET
POST
PUT
PATCH
DELETE
JSON requests
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
The #ui module contains concepts such as:
janela
div
section
main
header
footer
nav
h1
p
span
button
input
form
table
card
row
column
The goal is to provide a JLScript-native way to describe interfaces.
Styling
The #style module complements #ui.
import #style
It includes styling-oriented functionality and selector concepts such as:
class
classe
id
type
tipo
JLScript UI is still evolving as part of the broader ecosystem.
Time and durations
JLScript includes readable duration syntax.
Examples:
esperar(500ms)
esperar(2segundos)
esperar(1minuto)
Duration units include concepts such as:
ms
segundo
segundos
minuto
minutos
hora
horas
dia
dias
English variants are also supported.
Time utilities
JLScript provides time-related global functionality.
Examples include concepts such as:
tempo.agora()
and English equivalents:
time.now()
Other time APIs include scheduled and repeated execution concepts such as:
tempo.depois
tempo.cada
time.after
time.every
User interaction
JLScript includes built-in functions for terminal interaction.
va nome = ler("Digite seu nome: ")
mostrar(nome)
Confirmation functionality is also available through:
confirmar("Deseja continuar?")
or:
confirm("Continue?")
Terminal utilities
JLScript includes several useful terminal-oriented functions.
Examples include:
limpar()
titulo("Meu aplicativo")
mostrarAviso("Atenção")
mostrarErro("Algo deu errado")
mostrarSucesso("Operação concluída")
These APIs help developers build more complete command-line applications.
.jls files
JLScript source files use the .jls extension.
Example:
main.jls
A simple program could look like:
va linguagem = "JLScript"
func apresentar(nome) {
mostrar("Bem-vindo ao " + nome)
}
apresentar(linguagem)
JLScript CLI
JLScript includes a command-line interface for working with projects and source files.
Examples of commands include:
jls run
Run a JLScript project.
jls build
Build a project.
jls compile
Compile JLScript code.
jls test
Run tests.
jls fmt
Format JLScript source code.
jls lint
Analyze source code.
jls doctor
Check the development environment.
jls dev
Start development workflows.
Other CLI commands include:
preview
targets
clean
verify-bytecode
update
repl
config
new
create
init
fix
ai
language
linguagem
selfhost
Compilation
JLScript source code uses:
.jls
The compiler can generate:
.jlb
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
.jlscode - 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")
}
and:
if (ativo) {
mostrar("Active")
} else {
mostrar("Inactive")
}
Loops:
enquanto (ativo) {
mostrar("Executando")
}
or:
while (ativo) {
mostrar("Running")
}
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
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))
}
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)
The language is still growing.
So are its libraries.
So are its tools.
And so is its ecosystem.
JLScript: code that speaks your language.
Top comments (0)