DEV Community: JLScript

JLScript: Guia Completo da Sintaxe, do Básico ao Avançado

JLScript — Sat, 03 Oct 2026 22:41:07 +0000

🧛 JLScript — Do Básico ao Avançado

Aprenda JLScript do primeiro mostrar() até APIs, banco de dados, dispositivos e interfaces.

JLScript, também chamado de JLS, é uma linguagem de programação criada com o objetivo de possuir uma sintaxe simples, legível e agradável para quem está começando, sem impedir a criação de projetos maiores.

Os arquivos da linguagem utilizam a extensão:

.jls

Neste guia vamos começar absolutamente do zero.

No final, você já terá visto:

variáveis;
valores;
operadores;
condições;
loops;
funções;
listas;
objetos;
tratamento de erros;
módulos;
aliases;
tempo;
APIs;
banco de dados;
dispositivos;
interfaces gráficas;
organização de projetos.

1. Seu primeiro programa

Todo programador começa inevitavelmente imprimindo texto no terminal. A humanidade construiu compiladores, sistemas operacionais e inteligência artificial para, no fim, escrever "Olá, mundo!".

Em JLScript:

mostrar("Olá, mundo!")

A função mostrar() envia um valor para a saída do programa.

Podemos executar várias instruções:

mostrar("Olá!")
mostrar("Estou aprendendo JLScript")
mostrar("Meu primeiro programa está funcionando")

2. Variáveis

Variáveis são espaços usados para guardar informações.

No JLScript existem três formas principais de declaração:

va nome = "Lucas"
let idade = 20
ins ativo = true

Depois podemos utilizar os valores:

va linguagem = "JLScript"

mostrar(linguagem)

Valores básicos

Texto

va nome = "JLScript"

Número inteiro

va idade = 20

Número decimal

va preco = 19.90

Booleano

va online = true
va bloqueado = false

Valor vazio

va resultado = null

Podemos juntar tudo:

va nome = "Lucas"
va idade = 20
va programador = true
va projeto = "JLScript"

mostrar(nome)
mostrar(idade)
mostrar(programador)
mostrar(projeto)

3. Operadores matemáticos

JLScript suporta operações matemáticas comuns.

va soma = 10 + 5
va subtracao = 10 - 5
va multiplicacao = 10 * 5
va divisao = 10 / 5
va resto = 10 % 3

mostrar(soma)
mostrar(subtracao)
mostrar(multiplicacao)
mostrar(divisao)
mostrar(resto)

Incremento

va numero = 1

numero++

mostrar(numero)

Decremento

va numero = 10

numero--

mostrar(numero)

4. Comparações

Comparações produzem normalmente um resultado verdadeiro ou falso.

va idade = 20

mostrar(idade > 18)
mostrar(idade < 18)
mostrar(idade >= 18)
mostrar(idade <= 18)
mostrar(idade == 20)
mostrar(idade != 20)

Alguns operadores importantes:

Operador	Significado
`==`	igual
`!=`	diferente
`>`	maior
`<`	menor
`>=`	maior ou igual
`<=`	menor ou igual

5. Operadores lógicos

Também podemos juntar várias condições.

E

va idade = 20
va autorizado = true

se (idade >= 18 && autorizado) {
    mostrar("Entrada permitida")
}

OU

va admin = false
va moderador = true

se (admin || moderador) {
    mostrar("Acesso permitido")
}

NÃO

va bloqueado = false

se (!bloqueado) {
    mostrar("Usuário liberado")
}

6. Condições

Condições permitem executar diferentes partes do programa.

`se`

va idade = 20

se (idade >= 18) {
    mostrar("Você é maior de idade")
}

`se` e `senao`

va idade = 16

se (idade >= 18) {
    mostrar("Maior de idade")
} senao {
    mostrar("Menor de idade")
}

7. Condições em inglês

JLScript também possui estruturas equivalentes em inglês.

va idade = 20

if (idade >= 18) {
    mostrar("Adulto")
} else {
    mostrar("Menor")
}

Importante: mantenha o idioma da estrutura consistente.

Evite:

se (idade >= 18) {
    mostrar("Ok")
} else {
    mostrar("Não")
}

Prefira:

se (idade >= 18) {
    mostrar("Ok")
} senao {
    mostrar("Não")
}

ou:

if (idade >= 18) {
    mostrar("Ok")
} else {
    mostrar("Não")
}

8. Várias condições

Podemos verificar mais de uma possibilidade.

va nota = 8

se (nota >= 9) {
    mostrar("Excelente")
} senao se (nota >= 7) {
    mostrar("Aprovado")
} senao se (nota >= 5) {
    mostrar("Recuperação")
} senao {
    mostrar("Reprovado")
}

9. Enquanto

Quando queremos repetir algo enquanto uma condição for verdadeira:

va numero = 1

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

    numero++
}

Resultado esperado:

Em inglês:

va numero = 1

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

    numero++
}

10. Para

Quando já sabemos como a repetição deve avançar, podemos utilizar para.

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

Em inglês:

for (va i = 0; i < 10; i++) {
    mostrar(i)
}

11. Pare

Podemos interromper um loop.

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

    se (i == 5) {
        pare
    }

    mostrar(i)
}

Quando i chegar a 5, o loop será interrompido.

Em inglês:

break

12. Continuar

Podemos ignorar uma iteração específica.

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

    se (i == 5) {
        continuar
    }

    mostrar(i)
}

Nesse exemplo, o número 5 não será mostrado.

Em inglês:

continue

13. Funções

Funções permitem criar blocos reutilizáveis.

func saudacao() {
    mostrar("Olá!")
}

saudacao()

Podemos receber parâmetros:

func saudacao(nome) {
    mostrar("Olá " + nome)
}

saudacao("Lucas")

14. Retornando valores

Uma função também pode devolver um resultado.

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

Agora podemos utilizar:

va resultado = soma(10, 5)

mostrar(resultado)

15. Forma curta de função

JLScript também suporta uma forma curta de declaração.

soma(a, b) {
    retorne a + b
}

mostrar(soma(10, 5))

16. Parâmetros padrão

Podemos definir valores que serão usados caso nenhum argumento seja informado.

func saudacao(nome = "Mundo") {
    mostrar("Olá " + nome)
}

saudacao()

Resultado:

Olá Mundo

Agora:

saudacao("Lucas")

Resultado:

Olá Lucas

17. Argumentos nomeados

JLScript permite deixar chamadas maiores mais legíveis.

func criarUsuario(nome, idade, ativo = true) {
    mostrar(nome)
    mostrar(idade)
    mostrar(ativo)
}

Podemos chamar:

criarUsuario(
    nome = "Lucas",
    idade = 20,
    ativo = true
)

Assim fica muito mais fácil descobrir o significado de cada valor.

Compare:

criarUsuario("Lucas", 20, true)

com:

criarUsuario(
    nome = "Lucas",
    idade = 20,
    ativo = true
)

Em chamadas grandes, a segunda forma normalmente é muito mais clara.

18. Funções anônimas

Também podemos criar uma função sem nome.

va dobro = func(numero) {
    retorne numero * 2
}

Utilizando:

mostrar(dobro(10))

Resultado:

Funções anônimas ficam especialmente importantes quando começamos a trabalhar com callbacks.

19. Listas

Uma lista permite armazenar vários valores.

va linguagens = [
    "JLScript",
    "Python",
    "JavaScript"
]

Podemos acessar um elemento:

mostrar(linguagens[0])

Também podemos guardar números:

va numeros = [
    10,
    20,
    30,
    40
]

20. Objetos

Objetos agrupam informações relacionadas.

va usuario = {
    nome: "Lucas",
    idade: 20,
    programador: true
}

Acessando propriedades:

mostrar(usuario.nome)
mostrar(usuario.idade)
mostrar(usuario.programador)

Isso é muito melhor do que criar:

va usuarioNome = "Lucas"
va usuarioIdade = 20
va usuarioProgramador = true

principalmente quando o programa começa a crescer.

21. Escolha

Quando temos várias opções bem definidas:

va opcao = 2

escolha (opcao) {

    caso 1 {
        mostrar("Cadastrar")
    }

    caso 2 {
        mostrar("Entrar")
    }

    caso 3 {
        mostrar("Sair")
    }

    padrao {
        mostrar("Opção inválida")
    }
}

A forma inglesa:

switch (opcao) {

    case 1 {
        mostrar("Cadastrar")
    }

    case 2 {
        mostrar("Entrar")
    }

    default {
        mostrar("Opção inválida")
    }
}

22. Tratamento de erros

Programas reais falham.

Arquivo não existe, conexão cai, servidor some, usuário faz coisa inexplicável. Normal.

JLScript possui estruturas para tratamento de erros.

tente {

    mostrar("Executando operação")

} capture (erro) {

    mostrar("Ocorreu um erro")
    mostrar(erro)
}

23. Finalmente

Podemos executar um bloco independentemente de ocorrer erro.

tente {

    mostrar("Executando")

} capture (erro) {

    mostrar("Erro encontrado")

} finalmente {

    mostrar("Processo finalizado")
}

Em inglês:

try {

    mostrar("Executando")

} catch (error) {

    mostrar(error)

} finally {

    mostrar("Finalizado")
}

24. Bibliotecas

Até agora usamos principalmente recursos básicos da linguagem.

Para funcionalidades maiores, JLScript possui módulos.

Importando:

import #math

25. Vários imports

Podemos importar mais de um módulo:

import [
    #math,
    #json,
    #file
]

26. Alias de biblioteca

Também podemos mudar o nome utilizado dentro do código.

import #database como db

Agora:

db.

representa o módulo #database.

Um IntelliSense correto deve entender isso.

Depois de:

db.

ele deve mostrar somente recursos pertencentes ao módulo #database.

27. Tempo

JLScript possui suporte para trabalhar com durações de maneira legível.

esperar(2 segundos)

Depois:

mostrar("Dois segundos passaram")

Podemos utilizar outras unidades:

esperar(500 ms)

esperar(1 segundo)

esperar(2 minutos)

esperar(1 hora)

28. Tempo atual

JLScript possui um objeto global relacionado ao tempo.

va agora = tempo.agora()

mostrar(agora)

29. Executar algo depois

Podemos agendar uma função.

tempo.depois(2 segundos, func() {

    mostrar("Executado depois de 2 segundos")
})

Aqui aparece um conceito importante:

func() {
}

é uma função anônima usada como callback.

30. Repetir automaticamente

Também podemos executar uma função em intervalos.

va timer = tempo.cada(1 segundo, func() {

    mostrar("tick")
})

31. Criando uma API

Agora começamos a entrar em recursos mais avançados.

Importamos:

import #api

Criamos o servidor:

va app = api.criar(3000)

Agora criamos uma rota:

app.get("/", func(req, res) {

    res.enviar("Olá pelo JLScript!")
})

E iniciamos:

app.iniciar()

Programa completo:

import #api

va app = api.criar(3000)

app.get("/", func(req, res) {

    res.enviar("Olá pelo JLScript!")
})

app.iniciar()

32. Retornando objetos em uma API

Podemos trabalhar com dados estruturados.

app.get("/usuario", func(req, res) {

    va usuario = {
        nome: "Lucas",
        linguagem: "JLScript",
        online: true
    }

    res.enviar(usuario)
})

Aqui usamos juntos:

módulo;
rota;
callback;
objeto;
variável;
resposta HTTP.

33. Consumindo uma API

O módulo também pode ser usado para requisições HTTP.

import #api

va resposta = api.obter(
    "https://api.exemplo.com/usuarios"
)

mostrar(resposta)

34. Banco de dados

Importamos:

import #database como db

Agora abrimos SQLite:

va banco = db.sqlite("app.db")

Podemos executar uma instrução:

banco.executar(
    "CREATE TABLE usuarios (id INTEGER PRIMARY KEY, nome TEXT)"
)

Programa:

import #database como db

va banco = db.sqlite("app.db")

banco.executar(
    "CREATE TABLE usuarios (id INTEGER PRIMARY KEY, nome TEXT)"
)

35. Dispositivos

JLScript também possui recursos voltados a conexões e dispositivos.

import #connector
import #mobile

Uma conexão ADB pode ser criada:

va conexao = connector.adb(
    "192.168.1.2",
    5555,
    timeout = 20 segundos
)

Repare em:

timeout = 20 segundos

Aqui utilizamos ao mesmo tempo:

argumento nomeado;
valor numérico;
unidade de tempo.

36. Mobile

Depois de obter a conexão:

va celular = mobile.conectar(conexao)

Podemos trabalhar com o objeto retornado:

mostrar(celular.estatisticas())

Código:

import #connector
import #mobile

va conexao = connector.adb(
    "192.168.1.2",
    5555,
    timeout = 20 segundos
)

va celular = mobile.conectar(conexao)

mostrar(celular.estatisticas())

37. Criando interfaces

Agora podemos entrar em uma área diferente.

import [
    #ui,
    #style
]

Criamos uma janela:

va app = ui.janela()

Adicionamos um título:

app.titulo("Meu aplicativo")

38. Estrutura da interface

Podemos definir elementos:

app.ui({

    main(class="app") {

        h1("Bem-vindo")

        p("Aplicação criada com JLScript")

        button(class="acao") {
            text = "Entrar"
        }
    }
})

Aqui começamos a trabalhar com uma sintaxe especializada para interfaces.

39. Estilo

Depois podemos aplicar estilo:

app.style({

    background("#101010"),

    color("#ffffff")
})

40. Abrindo a janela

Por fim:

app.abrir()

Aplicação completa:

import [
    #ui,
    #style
]

va app = ui.janela()

app.titulo("JLScript App")

app.ui({

    main(class="app") {

        h1("Bem-vindo")

        p("Aplicação criada com JLScript")

        button(class="acao") {
            text = "Entrar"
        }
    }
})

app.style({

    background("#101010"),

    color("#ffffff")
})

app.abrir()

41. Organizando funções

Programação avançada não significa escrever código mais complicado.

Na maioria das vezes significa dividir melhor o problema.

Ruim:

va preco = 30
va quantidade = 4
va subtotal = preco * quantidade

se (subtotal > 100) {
    subtotal = subtotal * 0.9
}

mostrar(subtotal)

Podemos transformar essa lógica em função:

func calcularTotal(preco, quantidade) {

    va subtotal = preco * quantidade

    se (subtotal > 100) {
        retorne subtotal * 0.9
    }

    retorne subtotal
}

Agora:

va total = calcularTotal(30, 4)

mostrar(total)

A lógica ficou reutilizável.

42. Escopo

Variáveis criadas dentro de uma função pertencem àquele contexto.

func calcular() {

    va resultado = 10 + 5

    mostrar(resultado)
}

resultado existe dentro da função.

Esse conceito fica cada vez mais importante conforme o projeto cresce.

43. Juntando módulos

Podemos importar vários sistemas:

import [
    #api,
    #database,
    #json
]

Agora o programa pode ter:

servidor;
banco;
processamento de dados.

44. Projeto maior

Vamos juntar vários conceitos.

import [
    #api,
    #database
]

va banco = database.sqlite("usuarios.db")

Criamos uma função:

func criarUsuario(nome, idade) {

    se (nome == null) {
        retorne false
    }

    banco.executar(
        "INSERT INTO usuarios (nome, idade) VALUES (?, ?)"
    )

    retorne true
}

Agora criamos a API:

va app = api.criar(3000)

Criamos uma rota:

app.get("/", func(req, res) {

    res.enviar({
        linguagem: "JLScript",
        status: "online"
    })
})

E iniciamos:

app.iniciar()

45. Projeto completo

import [
    #api,
    #database
]

va banco = database.sqlite("usuarios.db")

func criarUsuario(nome, idade) {

    se (nome == null) {
        retorne false
    }

    banco.executar(
        "INSERT INTO usuarios (nome, idade) VALUES (?, ?)"
    )

    retorne true
}

va app = api.criar(3000)

app.get("/", func(req, res) {

    res.enviar({
        linguagem: "JLScript",
        status: "online"
    })
})

app.iniciar()

mostrar("Servidor iniciado")

Neste exemplo utilizamos:

imports;
módulos;
banco de dados;
variáveis;
funções;
parâmetros;
condições;
retorno;
callbacks;
objetos;
API HTTP.

46. Do básico ao avançado

Você começou aqui:

mostrar("Olá, mundo!")

Depois aprendeu:

va nome = "Lucas"

Passou para:

se (idade >= 18) {
    mostrar("Maior")
}

Depois:

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

Até chegar em:

import #api

e construir aplicações que podem trabalhar com:

APIs;
HTTP;
banco de dados;
arquivos;
JSON;
tempo;
rede;
dispositivos;
interfaces;
testes;
compilação.

🧛 Cores Dracula para JLScript

Para documentação e editores, uma identidade visual inspirada no Dracula Theme pode utilizar aproximadamente estas categorias:

Elemento JLScript	Cor Dracula
`se`, `senao`, `func`, `retorne`, `import`	Pink `#ff79c6`
Strings	Yellow `#f1fa8c`
Números	Purple `#bd93f9`
`#api`, `#ui`, `#database`	Cyan `#8be9fd`
Funções nativas	Green `#50fa7b`
Unidades de tempo	Orange `#ffb86c`
Comentários	Comment `#6272a4`
Texto normal	Foreground `#f8f8f2`
Fundo	Background `#282a36`

O arquivo Markdown não controla essas cores sozinho. O syntax highlighter do site/editor precisa possuir uma gramática JLScript e um tema Dracula.

📚 Ordem recomendada de estudo

mostrar()
valores
variáveis
operadores
condições
loops
funções
listas
objetos
tratamento de erros
imports
módulos
tempo
APIs
banco de dados
dispositivos
UI
organização de projetos

Conclusão

JLScript foi criada para permitir que alguém comece com:

mostrar("Olá")

sem exigir uma quantidade absurda de conhecimento inicial.

Mas a mesma linguagem pode continuar acompanhando o programador quando ele começa a trabalhar com:

import #api
import #database
import #connector
import #ui

A ideia não é apenas possuir uma sintaxe simples.

A ideia é criar um ecossistema no qual seja possível começar aprendendo programação e continuar evoluindo até construir aplicações maiores.

JLScript: simples para começar, poderosa para continuar.

JLScript — Identidade Visual Oficial

JLScript — Sat, 03 Oct 2026 00:58:33 +0000

Feita para aprender. Criada para evoluir.

JLScript: criando uma linguagem de programação brasileira do zero

JLScript — Tue, 29 Sep 2026 15:32:39 +0000

🇧🇷 JLScript: criando uma linguagem de programação brasileira do zero

Em 2026 comecei um projeto que inicialmente parecia relativamente simples:

criar minha própria linguagem de programação.

O nome dela é JLScript, ou simplesmente JLS.

Os arquivos utilizam a extensão:

.jls

No começo eu queria principalmente experimentar uma sintaxe que fosse simples para mim.

Só que existe um pequeno problema quando você decide criar uma linguagem:

você começa querendo interpretar algumas linhas de código e, quando percebe, está estudando lexer, parser, AST, runtime, escopos, compiladores, bytecode, concorrência, módulos e sabe-se lá mais o quê.

Foi exatamente o que aconteceu.

O que é JLScript?

JLScript é uma linguagem de programação brasileira que estou desenvolvendo principalmente em C++.

Minha ideia é combinar três coisas:

simplicidade
     +
produtividade
     +
capacidade de crescer

Não quero criar simplesmente outro Python ou outro JavaScript.

Naturalmente existem ideias inspiradas em linguagens que já utilizamos, mas também estou experimentando decisões próprias.

Hoje a arquitetura do projeto já envolve:

Código .jls
    │
    ▼
  Lexer
    │
    ▼
  Parser
    │
    ▼
   AST
    │
    ├──────────────┐
    ▼              ▼
Interpreter     Compiler
    │              │
    ▼              ▼
 Runtime        C++ / Bytecode

Português e inglês

Uma das ideias do JLScript é permitir construções em português e inglês.

Por exemplo:

se (idade >= 18) {
    mostrar('Maior de idade')
} senao {
    mostrar('Menor de idade')
}

Também posso escrever:

if (idade >= 18) {
    mostrar('Maior de idade')
} else {
    mostrar('Menor de idade')
}

Não quero que o português limite a linguagem ao Brasil.

Quero justamente que ela possa ter uma identidade brasileira e ainda permitir uma escrita familiar para desenvolvedores de outros lugares.

Variáveis

Atualmente a linguagem trabalha com formas como:

va nome = 'Lucas'
let linguagem = 'JLScript'
ins ativo = true

O runtime possui valores fundamentais como:

STRING
NUMBER
BOOLEAN
NULL
LIST
OBJECT
FUNCTION

Funções

Uma função pode ser declarada explicitamente:

func saudacao(nome) {
    mostrar('Olá, ' + nome)
}

Mas também criei uma forma curta:

soma(a, b) {
    retorne a + b
}

A ideia é simples:

se a estrutura já deixa claro que aquilo é uma função, por que obrigatoriamente adicionar outra palavra?

Uma decisão diferente no switch

Outra coisa que quis experimentar foi o switch.

Em várias linguagens encontramos algo parecido com:

case:
    ...
    break

No JLScript posso fazer:

switch (opcao) {

    case 1 {
        mostrar('Iniciar')
    }

    case 2 {
        mostrar('Configurações')
    }

    default {
        mostrar('Sair')
    }
}

Cada case possui seu próprio bloco.

O } já deixa claro onde aquele caso termina.

Então não preciso escrever break apenas para repetir essa informação.

Essa acabou se tornando uma das filosofias que tento seguir:

Se a própria estrutura do código já expressa claramente uma intenção, não quero adicionar sintaxe apenas porque outra linguagem faz assim.

O projeto cresceu bastante

A primeira versão oficial, JLScript 1.0.0, era muito menor.

Ela possuía principalmente:

if / else
funções
switch
for
loops
execução básica
CLI inicial

O terminal também era extremamente simples.

Um dos comandos era basicamente:

jls version

Mas aquela versão provou a coisa mais importante:

a linguagem funcionava.

Depois disso comecei a expandir o projeto.

Hoje sua estrutura envolve áreas como:

JLScript
│
├── Lexer
├── Parser
├── AST
├── Interpreter
├── Runtime
├── Execution Engine
├── Modules
├── Compiler
├── C++ Generator
├── Bytecode Compiler
├── CLI
└── Standard Library

CLI própria

A linguagem também ganhou uma CLI:

jls

Com o crescimento do projeto começaram a surgir comandos como:

jls run programa.jls
jls repl
jls build programa.jls
jls compile programa.jls
jls test
jls fmt
jls lint
jls fix
jls doctor
jls update
jls dev

Minha intenção é que o terminal seja parte importante da experiência da linguagem, e não simplesmente um executável que recebe um arquivo.

Compilação

Também comecei a experimentar compilação.

Um dos caminhos atuais utiliza geração de C++:

programa.jls
     │
     ▼
   Lexer
     │
     ▼
   Parser
     │
     ▼
    AST
     │
     ▼
Gerador C++
     │
     ▼
Compilador C++
     │
     ▼
 Executável

Ou seja, o código continua sendo escrito em JLScript, mas pode passar por uma etapa de geração e compilação nativa.

Bytecode

Existe também um compilador de bytecode.

Arquivos compilados podem utilizar:

.jlb

O fluxo é aproximadamente:

programa.jls
     │
     ▼
Bytecode Compiler
     │
     ▼
 programa.jlb

Essa parte ainda faz parte da evolução da arquitetura da linguagem.

Bibliotecas

Outra área que cresceu bastante foi o sistema de bibliotecas.

Uma biblioteca pode ser importada assim:

import #json

Ou várias:

import [#api, #database, #json]

O projeto já explora diferentes áreas:

#api
#database
#json
#ui
#style
#mobile
#connector
#compiler
#thread
#time
#file
#process
...

Minha ideia é manter funcionalidades especializadas fora do núcleo sempre que fizer sentido.

Interface gráfica usando JLScript

Uma das partes que mais estou experimentando atualmente é permitir construir interfaces utilizando a própria linguagem.

Por exemplo:

import [#ui, #style]

va app = ui.janela()

app.titulo('Login')

app.ui({

    div {
        text = 'Bem-vindo'
        button = 'Entrar'
    }

})

app.style({
    fundo: '#101010',
    cor: '#ffffff',
    largura: 800,
    altura: 600
})

app.abrir()

A ideia é aproximar algumas facilidades encontradas no desenvolvimento web da criação de aplicações usando JLScript.

Ainda existe bastante trabalho nessa área, mas é uma das partes que pretendo continuar desenvolvendo.

Criar uma linguagem me obrigou a aprender muita coisa

Essa provavelmente foi a parte mais interessante do projeto.

Quando comecei, eu não precisava conhecer profundamente todas as peças de uma linguagem.

Só que cada funcionalidade nova apresentava outro problema.

O processo acabou ficando parecido com isto:

Ideia
  ↓
Implementação
  ↓
Erro
  ↓
"por que isso aconteceu?"
  ↓
Pesquisa
  ↓
entender uma parte nova
  ↓
corrigir
  ↓
ter outra ideia

Criar funções me fez estudar escopos.

Criar sintaxe me fez estudar lexer e parser.

Criar execução me levou ao runtime.

Criar build me levou a compiladores.

Criar bibliotecas me levou a APIs nativas.

Criar servidores me levou a sockets e concorrência.

Uma coisa vai puxando outra.

Por que o nome JLScript?

O nome também tem uma história.

J       = Joicy
L       = Lucas
Script  = Programação

Portanto:

J + L + Script
      ↓
   JLScript

O J não significa Java nem JavaScript.

Ele representa Joicy Costa.

O L representa Lucas Aguiel Dos Santos De Oliveira, criador da linguagem.

Joicy não participa tecnicamente do desenvolvimento. A presença dela no nome é uma homenagem e registra uma parte da minha história pessoal dentro do projeto.

JLScript e JLScripter

Também existe uma diferença entre alguns nomes que utilizo:

JLScript
    ↓
a linguagem

JLS
    ↓
abreviação

.jls
    ↓
extensão dos arquivos

JLScripter
    ↓
o ecossistema ao redor da linguagem

Então penso no JLScripter aproximadamente assim:

JLScripter
│
├── JLScript
├── Interpreter
├── Runtime
├── Compiler
├── Bytecode
├── CLI
├── Libraries
├── Developer Tools
└── Documentation

Ainda está em desenvolvimento

JLScript não é um projeto que considero terminado.

Ainda existem partes experimentais, coisas que quero redesenhar, bibliotecas que precisam amadurecer e bastante trabalho no runtime e nas ferramentas.

Mas comparar a primeira versão com o projeto atual é uma das coisas que mais me motiva a continuar.

Começou assim:

condições
funções
loops
switch
CLI simples

E está caminhando para:

linguagem
+
runtime
+
compilação
+
bytecode
+
bibliotecas
+
interfaces
+
ferramentas

Ainda tenho bastante coisa para construir.

E provavelmente bastante coisa para quebrar também. Faz parte de criar uma linguagem do zero. 😅

🇧🇷 JLScript

Uma linguagem brasileira em desenvolvimento.

Simples para começar. Estruturada para crescer.

Criada por Lucas Aguiel Dos Santos De Oliveira.

JLScript: A Programming Language Designed to Make Coding Simpler

JLScript — Sun, 02 Aug 2026 20:12:29 +0000

Programming should be accessible to everyone, not just people who already speak English fluently.

JLScript is a programming language under development with the goal of making programming simpler, more intuitive, and more accessible, especially for beginners and Portuguese-speaking developers.

The language uses clear and readable syntax while keeping modern programming concepts such as variables, functions, conditions, loops, arrays, objects, modules, and API integration.

Main Goals
Simple and clean syntax
Easy to learn
High readability
Modern language features
Open-source project
Community-driven development
Example

va nome = "Lucas"

func cumprimentar(nome) {
    mostrar("Olá, " + nome + "!")
}

cumprimentar(nome)
Planned Features
Native HTTP API consumption
Package manager
Cross-platform compiler
VS Code extension
Modules and libraries
Object-Oriented Programming
Error handling
Arrays and dictionaries
File system support
JSON support
CLI tools

JLScript is still under active development, and many features are being improved continuously.

Feedback, ideas, and contributions are always welcome.

GitHub:

(https://github.com/eohlczinn/jlscript.dev)

Official Website:

(https://jlscript-dev.vercel.app/#/docs)

DEV Community: JLScript

JLScript: Guia Completo da Sintaxe, do Básico ao Avançado

🧛 JLScript — Do Básico ao Avançado

1. Seu primeiro programa

2. Variáveis

Valores básicos

Texto

Número inteiro

Número decimal

Booleano

Valor vazio

3. Operadores matemáticos

Incremento

Decremento

4. Comparações

5. Operadores lógicos

E

OU

NÃO

6. Condições

se

se e senao

7. Condições em inglês

8. Várias condições

9. Enquanto

10. Para

11. Pare

12. Continuar

13. Funções

14. Retornando valores

15. Forma curta de função

16. Parâmetros padrão

17. Argumentos nomeados

18. Funções anônimas

19. Listas

20. Objetos

21. Escolha

22. Tratamento de erros

23. Finalmente

24. Bibliotecas

25. Vários imports

26. Alias de biblioteca

27. Tempo

28. Tempo atual

29. Executar algo depois

30. Repetir automaticamente

31. Criando uma API

32. Retornando objetos em uma API

33. Consumindo uma API

34. Banco de dados

35. Dispositivos

36. Mobile

37. Criando interfaces

38. Estrutura da interface

39. Estilo

40. Abrindo a janela

41. Organizando funções

42. Escopo

43. Juntando módulos

44. Projeto maior

45. Projeto completo

46. Do básico ao avançado

🧛 Cores Dracula para JLScript

📚 Ordem recomendada de estudo

Conclusão

JLScript — Identidade Visual Oficial

JLScript: criando uma linguagem de programação brasileira do zero

🇧🇷 JLScript: criando uma linguagem de programação brasileira do zero

O que é JLScript?

Português e inglês

Variáveis

Funções

Uma decisão diferente no switch

O projeto cresceu bastante

CLI própria

Compilação

Bytecode

Bibliotecas

Interface gráfica usando JLScript

Criar uma linguagem me obrigou a aprender muita coisa

`se`

`se` e `senao`