DEV Community: JLScript

JLScript e open source?

JLScript — Fri, 16 Oct 2026 01:26:08 +0000

JLScript não é Open Source porque

O JLScript não é um projeto open source.

Isso significa que o código-fonte principal da linguagem, incluindo partes internas do interpretador, runtime, compilador, ferramentas centrais e outros componentes responsáveis pelo funcionamento interno do projeto, não é disponibilizado publicamente para livre acesso, modificação ou redistribuição.

A decisão de manter o núcleo do JLScript fechado faz parte da forma como o projeto está sendo desenvolvido e organizado.

O objetivo não é impedir que pessoas utilizem a linguagem, criem projetos, estudem sua sintaxe ou desenvolvam bibliotecas para o ecossistema. A proposta é proteger a implementação interna do projeto e manter um controle maior sobre sua evolução.

Usuários podem utilizar o JLScript através das ferramentas oficiais, documentação, bibliotecas e recursos disponibilizados publicamente.

O que permanece restrito é a implementação interna da linguagem.

O que isso significa na prática

O fato de o JLScript não ser open source não significa que a linguagem seja fechada para uso.

Desenvolvedores podem:

escrever programas em JLScript;
utilizar bibliotecas oficiais;
criar aplicações;
estudar a documentação;
aprender a sintaxe;
utilizar ferramentas do ecossistema;
criar bibliotecas próprias;
desenvolver projetos que utilizem JLScript;
compartilhar código escrito em .jls;
participar da comunidade;
enviar sugestões e relatar problemas.

O que não é disponibilizado publicamente é o código-fonte interno responsável pela implementação principal da linguagem.

Isso inclui partes responsáveis pelo funcionamento interno, execução e desenvolvimento do núcleo do projeto.

Código escrito em JLScript

Existe uma diferença importante entre o código-fonte da linguagem e o código criado pelos usuários utilizando JLScript.

Um desenvolvedor pode criar um programa como:

va nome = "JLScript"

se (nome == "JLScript") {
    mostrar("Olá!")
}

Esse código pertence ao projeto ou ao desenvolvedor que o criou, de acordo com a licença e os termos definidos por ele.

O fato de a implementação do JLScript ser fechada não significa que todo programa escrito utilizando a linguagem também seja fechado.

Um desenvolvedor pode, por exemplo, criar uma biblioteca em JLScript e decidir publicá-la como open source.

Outro desenvolvedor pode criar um sistema privado.

Outro pode desenvolver uma ferramenta gratuita.

Essas decisões pertencem ao autor de cada projeto.

Bibliotecas da comunidade

O ecossistema JLScript foi pensado para permitir que desenvolvedores criem suas próprias bibliotecas e recursos.

Essas bibliotecas podem possuir licenças diferentes da linguagem principal.

Por exemplo, um desenvolvedor pode criar:

minha-biblioteca.jls

e publicar essa biblioteca no GitHub utilizando uma licença open source.

Isso não altera a licença do núcleo do JLScript.

Dessa forma, o ecossistema pode possuir projetos abertos mesmo que a implementação principal da linguagem permaneça privada.

Por que o núcleo é fechado

A decisão de manter o código-fonte principal fechado está relacionada principalmente à proteção e ao controle do desenvolvimento da linguagem.

O JLScript ainda está em evolução.

Sua arquitetura, ferramentas, bibliotecas e sistemas internos continuam recebendo alterações.

Manter o núcleo privado permite que mudanças estruturais sejam realizadas de maneira controlada, sem que versões internas incompletas ou experimentais sejam tratadas como implementações oficiais.

Também permite manter uma única direção para o desenvolvimento do projeto.

A linguagem possui uma identidade própria, uma arquitetura própria e uma visão de desenvolvimento definida.

O código interno representa uma parte importante dessa identidade.

Segurança e integridade

Outro objetivo é proteger a integridade das distribuições oficiais.

Quando um usuário instala uma versão oficial do JLScript, a intenção é que exista uma origem clara para essa versão.

Distribuições oficiais devem ser identificáveis e separadas de versões modificadas por terceiros.

Isso ajuda a evitar situações em que uma versão modificada possa ser apresentada como se fosse uma versão oficial da linguagem.

O projeto busca manter uma diferença clara entre:

JLScript oficial

software de terceiros baseado ou integrado ao JLScript

Isso também facilita a manutenção, correção de erros e distribuição de atualizações.

Controle de versões

As versões oficiais do JLScript são definidas pelo projeto.

Atualizações podem incluir:

alterações na sintaxe;
novos recursos;
novas bibliotecas;
correções;
melhorias de desempenho;
ferramentas adicionais;
mudanças no runtime;
melhorias no compilador;
integrações com o ecossistema.

Manter o código principal fechado permite que essas mudanças sejam desenvolvidas e testadas antes de serem distribuídas oficialmente.

Documentação pública

Mesmo com o código-fonte fechado, a documentação da linguagem pode ser pública.

A documentação existe para explicar como utilizar o JLScript.

Ela pode incluir:

sintaxe;
funções;
operadores;
estruturas condicionais;
laços;
módulos;
bibliotecas;
comandos;
exemplos;
ferramentas;
APIs públicas;
comportamento esperado da linguagem.

Isso permite que desenvolvedores utilizem e aprendam JLScript sem precisar acessar sua implementação interna.

O objetivo é documentar como utilizar a linguagem, e não necessariamente como cada componente interno foi construído.

Transparência de uso

Ser um projeto de código fechado não significa esconder o funcionamento público da linguagem.

O comportamento da linguagem pode ser documentado.

Se uma função recebe determinados parâmetros e retorna determinado resultado, isso pode ser explicado normalmente.

Por exemplo:

mostrar("Olá")

não exige que o usuário conheça o código interno responsável por implementar mostrar().

O desenvolvedor precisa conhecer sua função, comportamento e forma correta de utilização.

Esse é o mesmo princípio utilizado em diversos softwares proprietários.

JLScript e software proprietário

O JLScript pode ser classificado como um projeto de código-fonte fechado ou software proprietário, dependendo da licença adotada oficialmente para sua distribuição.

Isso significa que a utilização do software é permitida conforme os termos definidos pelo projeto, mas o código-fonte principal não é disponibilizado sob uma licença de software livre ou open source.

É importante não confundir:

gratuito

com:

open source

Um software pode ser gratuito para uso e continuar sendo proprietário.

Da mesma forma, um software open source pode possuir serviços pagos.

São conceitos diferentes.

Distribuição

As versões oficiais devem ser disponibilizadas pelos canais definidos pelo projeto JLScript.

Esses canais podem incluir:

site oficial;
documentação oficial;
repositórios públicos de documentação;
ferramentas de instalação;
extensões oficiais;
páginas oficiais do projeto.

O uso de canais oficiais ajuda o usuário a identificar a versão legítima do JLScript.

Extensão para VS Code

A extensão do JLScript para o Visual Studio Code faz parte do ecossistema da linguagem.

Dependendo da forma como cada componente for distribuído, ferramentas auxiliares podem ter regras de licenciamento diferentes do núcleo principal.

Isso significa que o projeto pode decidir, por exemplo, tornar determinada ferramenta aberta no futuro sem necessariamente abrir toda a implementação da linguagem.

Cada componente pode possuir sua própria política de distribuição.

JLShell

O JLShell é uma das ferramentas relacionadas ao ambiente JLScript.

Ele fornece acesso a comandos como:

jls run
jls build
jls test
jls fmt
jls lint

Mesmo que o usuário possa executar esses comandos e conhecer seu comportamento, isso não exige que a implementação interna dessas ferramentas seja pública.

JLS AI

O mesmo princípio pode ser aplicado ao JLS AI.

O projeto pode disponibilizar funcionalidades para usuários sem necessariamente disponibilizar publicamente todo o código responsável por sua implementação.

A documentação pode explicar como utilizar a ferramenta, seus recursos e limitações sem revelar sua estrutura interna completa.

Contribuições

A ausência de código-fonte público não impede necessariamente a participação da comunidade.

Usuários ainda podem contribuir através de:

sugestões;
relatórios de erros;
documentação;
exemplos;
bibliotecas;
projetos;
discussões;
testes;
feedback sobre novas funcionalidades.

A forma como essas contribuições serão aceitas depende das regras estabelecidas pelo projeto.

O que não é permitido

Sem autorização expressa ou uma licença que permita determinada ação, o fato de alguém conseguir utilizar ou acessar partes do software não significa que essa pessoa possui autorização para redistribuir, modificar ou publicar a implementação interna.

As permissões devem seguir a licença e os termos oficiais do JLScript.

Por isso, qualquer uso envolvendo redistribuição, engenharia reversa, modificação de componentes internos ou criação de versões derivadas deve respeitar os termos definidos pelo projeto e a legislação aplicável.

Possíveis mudanças futuras

A política de código-fonte do JLScript pode evoluir no futuro.

O projeto pode decidir abrir componentes específicos sem tornar todo o sistema open source.

Por exemplo, futuramente podem existir:

bibliotecas oficiais abertas;
SDKs públicos;
ferramentas auxiliares open source;
exemplos;
extensões;
APIs;
projetos comunitários.

Isso não significa que o núcleo da linguagem precise seguir a mesma política.

O modelo pode ser híbrido.

Uma linguagem aberta para criar, não necessariamente aberta por dentro

A ideia principal é simples:

o JLScript pode ser aberto para uso, aprendizado, criação e expansão do ecossistema sem que sua implementação principal seja open source.

Desenvolvedores podem aprender a linguagem, criar aplicações, desenvolver bibliotecas e participar da comunidade.

Enquanto isso, o núcleo permanece sob controle do projeto.

Essa separação permite proteger a implementação principal sem impedir o crescimento da linguagem.

Resumo

O JLScript:

não é open source;
possui código-fonte principal privado;
pode ter documentação pública;
pode ser utilizado por desenvolvedores;
permite a criação de projetos em .jls;
pode permitir bibliotecas da comunidade;
pode possuir componentes públicos no futuro;
mantém o núcleo oficial sob controle do projeto.

A intenção é manter uma estrutura clara entre a linguagem oficial, suas ferramentas internas e os projetos criados pelos usuários.

JLScript é uma linguagem disponível para criar, aprender e desenvolver, enquanto sua implementação principal permanece protegida e controlada pelo projeto.

SINTAXE DA JLSCRIPTER

JLScript — Fri, 16 Oct 2026 01:24:38 +0000

Sintaxe do JLScript

1. Primeiro programa

O comando mais básico do JLScript é mostrar():

mostrar("Olá, mundo!")

Também existe o alias:

show("Hello, world!")

2. Variáveis

O JLScript possui diferentes formas de declaração.

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

Também pode ser utilizado:

let nome = "Lucas"

ins valor = 100

Exemplo:

va linguagem = "JLScript"
va versao = 2.3
va publicado = true

mostrar(linguagem)
mostrar(versao)
mostrar(publicado)

3. Tipos de valores

O JLScript trabalha com valores como:

va texto = "JLScript"
va numero = 10
va decimal = 10.5
va ativo = true
va desligado = false
va vazio = null

Os principais valores básicos incluem:

string
number
boolean
null

Também existem conversões:

int("10")
float("10.5")
str(100)
bool(1)

4. Strings

Strings podem armazenar texto:

va nome = "Lucas"
va linguagem = "JLScript"

Exemplo:

mostrar("Olá")
mostrar("Bem-vindo ao JLScript")

5. Números

Inteiros:

va idade = 20

Decimais:

va preco = 19.90

6. Booleanos

va ligado = true
va desligado = false

Exemplo:

va servidorAtivo = true

se (servidorAtivo) {
    mostrar("Servidor ativo")
}

7. Null

va usuario = null

Pode ser utilizado para representar ausência de valor.

8. Operadores matemáticos

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

Exemplo:

va a = 10
va b = 5

mostrar(a + b)
mostrar(a - b)
mostrar(a * b)
mostrar(a / b)
mostrar(a % b)

9. Operadores de comparação

Exemplo:

va idade = 20

mostrar(idade >= 18)

10. Operadores lógicos

AND:

&&

OR:

||

NOT:

Exemplo:

va idade = 20
va ativo = true

se (idade >= 18 && ativo) {
    mostrar("Acesso permitido")
}

Outro exemplo:

se (idade < 18 || !ativo) {
    mostrar("Acesso bloqueado")
}

11. Incremento e decremento

va numero = 0

numero++
numero--

Exemplo:

va contador = 0

contador++
contador++

mostrar(contador)

12. Condições

Português

se (condicao) {
    mostrar("Verdadeiro")
}

Com senao:

va idade = 20

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

Inglês

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

O ideal é manter o mesmo idioma dentro da estrutura:

se (...) {
} senao {
}

ou:

if (...) {
} else {
}

13. While / Enquanto

Português:

va numero = 0

enquanto (numero < 5) {
    mostrar(numero)

    numero++
}

Inglês:

va numero = 0

while (numero < 5) {
    mostrar(numero)

    numero++
}

14. For / Para

Português:

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

Inglês:

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

15. Break / Pare

Português:

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

    se (i == 5) {
        pare
    }

    mostrar(i)
}

Inglês:

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

    if (i == 5) {
        break
    }

    mostrar(i)
}

16. Continue / Continuar

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

    se (i == 2) {
        continuar
    }

    mostrar(i)
}

Em inglês:

for (va i = 0; i < 5; i++) {

    if (i == 2) {
        continue
    }

    mostrar(i)
}

17. Funções

Forma padrão:

func ola() {
    mostrar("Olá")
}

Chamando:

ola()

18. Funções com parâmetros

func apresentar(nome) {
    mostrar(nome)
}

apresentar("Lucas")

19. Return / Retorne

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

va resultado = soma(10, 5)

mostrar(resultado)

20. Forma curta de função

JLScript também possui a forma curta:

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

Uso:

mostrar(soma(5, 10))

21. Parâmetros padrão

func apresentar(nome = "Visitante") {
    mostrar(nome)
}

Uso:

apresentar()
apresentar("Lucas")

22. Argumentos nomeados

JLScript também suporta argumentos nomeados.

Exemplo:

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

Chamada:

usuario(
    nome = "Lucas",
    idade = 20
)

Também podem existir chamadas utilizando ::

usuario(
    nome: "Lucas",
    idade: 20
)

Depois que argumentos nomeados começam a ser utilizados, o ideal é não misturar posicionais depois deles.

23. Funções anônimas

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

Uso:

saudacao("Lucas")

24. Listas

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

Acesso:

mostrar(linguagens[0])

Também pode ser usado em variáveis:

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

25. Objetos

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

Acesso:

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

26. Objetos dentro de objetos

va usuario = {

    nome: "Lucas",

    endereco: {
        cidade: "Águas Lindas",
        estado: "GO"
    }
}

Acesso:

mostrar(usuario.endereco.cidade)

27. Listas dentro de objetos

va projeto = {

    nome: "JLScript",

    tecnologias: [
        "C++",
        "Python",
        "JavaScript"
    ]
}

28. Switch / Escolha

Em inglês:

va opcao = 2

switch (opcao) {

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

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

    default {
        mostrar("Outra opção")
    }
}

Em português:

va opcao = 2

escolha (opcao) {

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

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

    padrao {
        mostrar("Outra opção")
    }
}

29. Tratamento de erros

Português:

tente {

    mostrar("Executando")

} capture (erro) {

    mostrar(erro)

} finalmente {

    mostrar("Finalizado")
}

Em inglês:

try {

    mostrar("Executando")

} catch (erro) {

    mostrar(erro)

} finally {

    mostrar("Finalizado")
}

30. Importação de módulos

Forma simples:

import #math

Outro exemplo:

import #api

31. Importação de vários módulos

import [
    #api,
    #json,
    #database
]

32. Alias de módulos

import #database como db

Depois:

db

representa o módulo importado.

33. Algumas bibliotecas do JLScript

Exemplos:

import #api
import #math
import #json
import #database
import #file
import #system
import #connector
import #mobile
import #ui
import #style
import #net
import #crypto
import #process
import #thread
import #image
import #audio
import #email
import #test

34. Tempo

JLScript possui suporte a durações legíveis.

Exemplo:

esperar(2 segundos)

Também:

esperar(500 ms)

Unidades podem incluir:

ms
segundo
segundos
minuto
minutos
hora
horas
dia
dias

35. Tempo atual

Português:

mostrar(tempo.agora())

Inglês:

mostrar(time.now())

36. Executar depois de um tempo

tempo.depois(2 segundos, func() {

    mostrar("Executado depois")

})

Em inglês:

time.after(2 segundos, func() {

    mostrar("Executado depois")

})

37. Executar repetidamente

tempo.cada(5 segundos, func() {

    mostrar("Executando")

})

Ou:

time.every(5 segundos, func() {

    mostrar("Executando")

})

38. Entrada de dados

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

mostrar(nome)

39. Espera

esperar(1 segundo)

Alias:

wait(1 segundo)

40. Confirmação

va resposta = confirmar("Deseja continuar?")

Também existe:

va resposta = confirm("Continuar?")

41. Limpar terminal

limpar()

42. Título

titulo("Meu programa")

43. Avisos

mostrarAviso("Atenção")

Erro:

mostrarErro("Erro encontrado")

Sucesso:

mostrarSucesso("Operação concluída")

44. API

Importação:

import #api

A biblioteca #api é voltada para comunicação HTTP e criação de serviços.

Um projeto normalmente começa com:

import #api

e utiliza os recursos públicos disponíveis no módulo para criar servidor, realizar requisições e trabalhar com respostas HTTP.

45. JSON

import #json

Pode ser utilizado para trabalhar com dados JSON dentro do projeto.

46. Banco de dados

import #database

Com alias:

import #database como db

47. Arquivos

import #file

A biblioteca é destinada à manipulação de arquivos e diretórios.

48. Sistema

import #system

Também existem objetos globais relacionados ao ambiente:

system
tempo
time

49. Matemática

import #math

Exemplos de operações disponíveis no módulo:

math.raiz(25)
math.absoluto(-10)
math.arredondar(10.6)
math.teto(10.1)
math.piso(10.9)

Também existem constantes matemáticas como:

math.PI
math.E

50. Interface gráfica

import [
    #ui,
    #style
]

Essas bibliotecas são utilizadas para criação e estilização de interfaces.

Exemplo conceitual:

import [
    #ui,
    #style
]

va app = ui.janela()

A interface pode ser construída utilizando elementos como:

div
section
main
header
footer
nav
h1
h2
p
span
input
textarea
select
button
form
table

51. Estilos

A biblioteca:

import #style

trabalha com propriedades de estilo, como:

background
color
width
height
margin
padding
border
borderRadius
fontSize
fontWeight
display
gap
position
opacity

Também existem efeitos como:

shadow
blur
brightness
scale
rotate
translate
transition

52. Dispositivos

import #connector

A biblioteca permite trabalhar com conexões.

Exemplos de recursos públicos incluem:

connector.ip(...)
connector.adb(...)
connector.usb(...)
connector.bluetooth(...)

53. Mobile

import #mobile

Utilizado para integração com dispositivos móveis suportados pelo ecossistema.

54. Rede

import #net

Voltado para funcionalidades como:

DNS
hostname
IP local
ping
TCP
UDP

55. Processos

import #process

Funções relacionadas a processos incluem operações como:

executar
iniciar
listar
existe

56. Thread

import #thread

Pode ser utilizado para operações relacionadas a execução concorrente.

57. Criptografia

import #crypto

Pode fornecer recursos relacionados a:

UUID
random
Base64
HMAC
AES

58. Testes

import #test

A biblioteca possui recursos para testar valores.

Exemplos de operações:

igual
diferente
verdadeiro
falso
maior
menor
nulo
naoNulo
contem
erro

59. Exemplo maior

import [
    #math,
    #json
]

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

func verificarUsuario(usuario) {

    se (usuario.ativo && usuario.idade >= 18) {

        mostrar("Usuário autorizado")

        retorne true

    } senao {

        mostrar("Usuário não autorizado")

        retorne false
    }
}

va autorizado = verificarUsuario(usuario)

se (autorizado) {

    va numero = 25
    va resultado = math.raiz(numero)

    mostrar(resultado)
}

60. Estrutura de projeto

Um projeto JLScript pode ser organizado assim:

meu-projeto/
│
├── main.jls
│
├── src/
│   ├── usuario.jls
│   ├── servidor.jls
│   └── database.jls
│
├── modules/
│
└── assets/

O arquivo principal normalmente possui extensão:

.jls

61. Executando

jls run main.jls

62. Build

jls build

63. Compilação

jls compile arquivo.jls

O compilador também pode gerar formato próprio utilizado pelo ecossistema JLScript.

64. Testes

jls test

65. Formatação

jls fmt

66. Lint

jls lint

67. Doctor

jls doctor

Serve para verificar o ambiente e possíveis problemas de configuração.

68. Atualização

jls update

69. REPL

jls repl

Permite trabalhar com a linguagem de forma interativa.

70. Regra importante do JLScript

Um dos conceitos mais importantes da linguagem é a consistência da estrutura.

Por exemplo:

se (...) {
} senao {
}

if (...) {
} else {
}

Em vez de misturar:

se (...) {
} else {
}

A ideia é manter a estrutura visual e linguística previsível.

Exemplo final

import [
    #math,
    #json,
    #file
]

va programa = {
    nome: "JLScript",
    versao: 2.3,
    ativo: true
}

func status(programa) {

    se (!programa.ativo) {
        retorne "desativado"
    }

    retorne "ativo"
}

func calcular(a, b = 10) {
    retorne a + b
}

va resultado = calcular(
    a = 20,
    b = 30
)

mostrar(programa.nome)
mostrar(status(programa))
mostrar(resultado)

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

    se (i == 3) {
        continuar
    }

    mostrar(i)
}

tente {

    mostrar("Executando JLScript")

} capture (erro) {

    mostrarErro(erro)

} finalmente {

    mostrar("Programa finalizado")
}

Historia do Criador da JSLcript

JLScript — Fri, 16 Oct 2026 01:21:29 +0000

A história por trás do JLScript

O JLScript nasceu de uma ideia pessoal.

Antes de existir como linguagem, existia apenas a vontade de entender programação de um jeito mais profundo. Lucas Aguiel começou estudando outras linguagens, criando projetos, testando possibilidades e tentando compreender não apenas como escrever código, mas também como uma linguagem funciona por trás de tudo aquilo que aparece na tela.

Durante esse processo, algumas dificuldades começaram a ficar claras. Muitas vezes, a sintaxe parecia mais complicada do que a ideia que ele queria expressar. Algumas tarefas simples exigiam estruturas maiores do que deveriam, e isso despertou uma pergunta que acabou se tornando o ponto de partida do projeto:

“E se eu criasse minha própria linguagem?”

No início, a ideia era pequena. Não existia a intenção de criar um ecossistema inteiro, ferramentas próprias, bibliotecas ou uma identidade completa. A proposta era apenas desenvolver uma sintaxe que fosse mais natural, simples de ler e mais próxima da forma como Lucas gostaria de programar.

Foi assim que começaram os primeiros experimentos.

Variáveis, condições, funções e laços foram sendo criados aos poucos. A linguagem começou a receber estruturas em português e inglês, permitindo que o programador pudesse escolher uma forma mais confortável de escrever.

Exemplos simples passaram a representar bem essa ideia:

va nome = "Lucas"

se (nome == "Lucas") {
    mostrar("Olá")
}

Aos poucos, aquilo deixou de ser apenas uma experiência.

O projeto começou a ganhar organização, regras próprias e novos recursos. A sintaxe foi evoluindo, novas estruturas foram adicionadas e o JLScript começou a se transformar em uma linguagem com identidade própria.

A origem do nome

O nome JLScript também nasceu de algo pessoal.

As letras representam:

J, de Joicy Costa;
L, de Lucas Aguiel;
S, de Script.

Joicy, namorada de Lucas, passou a fazer parte da identidade da linguagem através do próprio nome.

Dessa forma, JLScript não representa apenas um projeto técnico. O nome carrega também uma parte da história pessoal de quem criou a linguagem e de alguém importante durante esse período de desenvolvimento.

O nome acabou se tornando uma marca para tudo que viria depois.

Quando o projeto começou a crescer

Com o avanço do desenvolvimento, Lucas começou a perceber que, para o JLScript funcionar de verdade, não bastava apenas inventar palavras-chave.

Uma linguagem precisava entender o código.

Precisava ler o que foi escrito, reconhecer cada estrutura, interpretar expressões, executar instruções, lidar com erros e permitir que diferentes partes do programa trabalhassem juntas.

Foi nesse momento que o projeto começou a ficar muito maior.

O JLScript passou a desenvolver componentes responsáveis pela análise e execução do código. Aos poucos, foram surgindo sistemas de interpretação, módulos, bibliotecas e ferramentas para trabalhar com arquivos .jls.

O que antes era:

“quero criar uma sintaxe mais simples”

começou a se transformar em:

“quero construir uma linguagem de programação completa”.

E, como costuma acontecer em programação, a frase “é só fazer uma coisinha” resolveu criar uma família inteira de problemas.

As bibliotecas

Uma das etapas mais importantes foi a expansão da linguagem através de bibliotecas.

O objetivo era permitir que o JLScript não ficasse limitado apenas a cálculos ou exemplos básicos.

Começaram a surgir módulos para diferentes áreas, incluindo:

APIs;
matemática;
arquivos;
banco de dados;
interfaces;
rede;
processos;
dispositivos;
imagens;
áudio;
criptografia;
testes;
ferramentas do sistema.

Isso permitiu que a linguagem começasse a caminhar para um objetivo maior: ser utilizada em diferentes tipos de projetos.

O sistema de módulos passou a fazer parte da identidade da linguagem:

import #api
import #database
import #ui

A ideia era manter tudo simples visualmente, mesmo quando o projeto por trás fosse ficando mais complexo.

O nascimento do JLShell

Com a evolução do JLScript, surgiu também a necessidade de uma ferramenta própria para executar e gerenciar projetos.

Foi assim que nasceu o JLShell.

A linha de comando passou a oferecer formas de executar arquivos, testar projetos, formatar código, verificar problemas e construir aplicações.

Comandos como:

jls run arquivo.jls
jls build
jls test
jls fmt
jls lint

passaram a fazer parte do fluxo de desenvolvimento.

O JLScript começava, então, a deixar de ser apenas uma linguagem e começava a formar um ecossistema.

O JLS AI

Outra ideia que surgiu durante a evolução do projeto foi o JLS AI.

A proposta era criar uma ferramenta de inteligência artificial integrada ao próprio ecossistema da linguagem.

A ideia não era apenas responder perguntas, mas entender o JLScript, compreender código, auxiliar o programador, identificar problemas e, futuramente, trabalhar de forma cada vez mais integrada às ferramentas de desenvolvimento.

O JLS AI representa uma das partes mais ambiciosas do projeto, porque aproxima a linguagem de uma visão maior de desenvolvimento assistido.

Uma linguagem em português e inglês

Desde cedo, uma das ideias centrais do JLScript foi permitir que o código pudesse ser escrito de maneira natural.

Por isso, várias estruturas possuem versões em português e inglês.

Por exemplo:

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

if (idade >= 18) {
    mostrar("Maior de idade")
}

A intenção nunca foi simplesmente traduzir outra linguagem.

O objetivo era criar uma linguagem própria, mas que permitisse ao programador escolher uma forma mais confortável de escrever.

Essa característica acabou se tornando uma das marcas do projeto.

O objetivo

Desde o início, o objetivo do JLScript foi se tornando cada vez mais claro:

tornar a programação mais simples de ler e escrever sem impedir que o programador crie projetos maiores.

A ideia é permitir que alguém comece com:

mostrar("Olá, mundo!")

e, com o tempo, possa trabalhar com APIs, bancos de dados, interfaces, sistemas, dispositivos e outras áreas.

O projeto busca crescer junto com quem programa.

O que começou como curiosidade

O JLScript começou como uma curiosidade pessoal.

Uma tentativa de entender melhor programação.

Uma vontade de criar algo próprio.

Uma ideia que poderia ter terminado em alguns arquivos de teste.

Mas continuou crescendo.

Vieram a sintaxe, o interpretador, as bibliotecas, as ferramentas, a documentação, a extensão para o VS Code, o JLShell, o JLS AI e uma identidade visual própria.

O projeto passou a ter site, documentação pública e ferramentas voltadas para quem quiser aprender ou experimentar a linguagem.

E, no centro de tudo, continua existindo a mesma ideia que deu origem ao projeto:

programar deveria ser mais simples de entender.

Lucas, Joicy e JLScript

A história do JLScript também carrega uma parte da vida de Lucas.

O próprio nome da linguagem une Lucas e Joicy.

O J representa Joicy Costa.

O L representa Lucas Aguiel.

E o S representa Script.

Por isso, o nome acabou se tornando mais do que apenas uma sigla técnica.

Ele representa uma fase da vida do criador, uma relação importante e um projeto que foi crescendo durante esse período.

Joicy não aparece apenas como uma referência externa ao projeto.

Ela faz parte da própria origem do nome que identifica a linguagem.

O futuro

O JLScript continua em desenvolvimento.

A intenção é ampliar o número de bibliotecas, melhorar as ferramentas existentes, expandir o suporte a diferentes plataformas e permitir que a linguagem seja utilizada em cada vez mais áreas.

O objetivo de longo prazo é que o JLScript possa ser utilizado em diferentes tipos de aplicações e por diferentes tipos de desenvolvedores.

O projeto ainda está evoluindo, e muita coisa pode mudar.

Mas a essência continua a mesma.

Uma linguagem criada a partir de uma dificuldade pessoal, transformada em projeto, e construída com a intenção de tornar o código mais simples, mais legível e mais próximo de quem programa.

JLScript: código que fala a sua língua.

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)