Skip to content
Back to search

tinystruct

A lightweight, modular Java application framework for web and CLI development, designed for AI integration and plugin-based architecture. Enabling developers to create robust solutions with ease for building efficient and scalable applications.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/tinystruct/tinystruct with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/tinystruct/tinystruct'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/tinystruct--tinystruct/badge.svg)](/listings/tinystruct--tinystruct)

HTML

<a href="/listings/tinystruct--tinystruct"><img src="/api/listings/tinystruct--tinystruct/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

* Add the dependency into your pom.xml.

<dependency>
  <groupId>org.tinystruct</groupId>
  <artifactId>tinystruct</artifactId>
  <version>1.7.35</version>
</dependency>

To use the framework as a standalone command-line tool, build the optional jar that bundles all dependencies (about 50 MB, not part of the release):

./mvnw package -Pstandalone        # Windows: mvnw.cmd package -Pstandalone
java -jar target/tinystruct-1.7.35-jar-with-dependencies.jar --help

* Extend the AbstractApplication in Java:

package tinystruct.examples;

import org.tinystruct.AbstractApplication;
import org.tinystruct.ApplicationException;
import org.tinystruct.system.annotation.Action;

public class example extends AbstractApplication {

    @Override
    public void init() {
        // TODO Auto-generated method stub
    }

    @Override
    public String version() {
        return "1.0";
    }

    @Action("praise")
    public String praise() {
        return "Praise the Lord!";
    }

    @Action("say")
    public String say() throws ApplicationException {
        if (null != getContext().getAttribute("--words"))
            return getContext().getAttribute("--words").toString();

        throw new ApplicationException("Could not find the parameter <i>words</i>.");
    }

    @Action("say")
    public String say(String words) {
        return words;
    }

    @Action(value = "hello", mode = Mode.HTTP_GET)
    public String helloGet() {
        return "GET";
    }

    @Action(value = "hello", mode = Mode.HTTP_POST)
    public String helloPost() {
        return "POST";
    }

}

Smalltalk: <a href="https://github.com/tinystruct/smalltalk">https://github.com/tinystruct/smalltalk</a>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 234 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. `"How many are your works, O LORD ! In wisdom you made them all; the earth is full of your creatures."`
  2. ***Psalms 104:24***
  3. <img width="1774" height="887" alt="Image" src="https://github.com/user-attachments/assets/0e2c7a76-48f8-4075-9805-a332ca928dc8" />
  4. Language: [English](README.md) | [Português (Brasil)](docs/README.pt-BR.md) | [简体中文](docs/README.zh-CN.md) | [繁體中文](docs/README.zh-TW.md) | [日本語](docs/README.ja.md) | [한국어](docs/README.ko.md) | [Türkçe](docs/README.tr.md) | [Русский](docs/README.ru.md) | [Tiếng Việt](docs/README.vi.md) | [ไทย](docs/README.th.md) | [Deutsch](docs/README.de.md) | [Español](docs/README.es.md)
  5. The tinystruct framework
  6. --
  7. A simple framework for Java development. Simple thinking, Better design, Easy to be used with better performance!
  8. [![MvnRepository](https://badges.mvnrepository.com/badge/org.tinystruct/tinystruct/badge.svg?label=MvnRepository)](https://mvnrepository.com/artifact/org.tinystruct/tinystruct)
  9. [![Maven Central](https://img.shields.io/maven-central/v/org.tinystruct/tinystruct?label=Maven%20Central)](https://central.sonatype.com/artifact/org.tinystruct/tinystruct)
  10. [![Build](https://github.com/tinystruct/tinystruct/actions/workflows/build.yml/badge.svg)](https://github.com/tinystruct/tinystruct/actions/workflows/build.yml)
  11. [![CodeQL](https://github.com/tinystruct/tinystruct/actions/workflows/codeql.yml/badge.svg)](https://github.com/tinystruct/tinystruct/actions/workflows/codeql.yml)
  12. [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
  13. ![Java 17+](https://img.shields.io/badge/Java-17%2B-orange)
  14. [![GitHub Stars](https://img.shields.io/github/stars/tinystruct/tinystruct?style=flat)](https://github.com/tinystruct/tinystruct/stargazers)
  15. [![Last Commit](https://img.shields.io/github/last-commit/tinystruct/tinystruct)](https://github.com/tinystruct/tinystruct/commits/master)
  16. ## Prerequisites
  17. - Java Development Kit (JDK) 17 or higher
  18. - Maven (for dependency management)
  19. - A text editor or IDE (IntelliJ IDEA, Eclipse, VS Code, etc.)
  20. Getting Started with tinystruct archetype
  21. --
  22. You can follow this archetype to create a tinystruct-based project quickly: https://github.com/tinystruct/tinystruct-archetype
  23. Or create a project with a single command (Linux/macOS, requires JDK 17+ and Maven; choose basic, web, mcp, workflow or agent):
  24. ```bash
  25. curl -fsSL https://tinystruct.org/create | sh
  26. ```
  27. On Windows (requires Git for Windows or WSL), run this in PowerShell:
  28. ```powershell
  29. irm https://tinystruct.org/create.ps1 | iex
  30. ```
  31. Installation and Getting Started Manually
  32. --
  33. * Add the dependency into your pom.xml.
  34. ```xml
  35. <dependency>
  36. <groupId>org.tinystruct</groupId>
  37. <artifactId>tinystruct</artifactId>
  38. <version>1.7.38</version>
  39. </dependency>
  40. ```
  41. To use the framework as a standalone command-line tool, build the optional jar that bundles all dependencies (about 50 MB, not part of the release):
  42. ```bash
  43. ./mvnw package -Pstandalone # Windows: mvnw.cmd package -Pstandalone
  44. java -jar target/tinystruct-1.7.38-jar-with-dependencies.jar --help
  45. ```
  46. * Extend the AbstractApplication in Java:
  47. ```java
  48. package tinystruct.examples;
  49. import org.tinystruct.AbstractApplication;
  50. import org.tinystruct.ApplicationException;
  51. import org.tinystruct.system.annotation.Action;
  52. public class example extends AbstractApplication {
  53. @Override
  54. public void init() {
  55. // TODO Auto-generated method stub
  56. }
  57. @Override
  58. public String version() {
  59. return "1.0";
  60. }
  61. @Action("praise")
  62. public String praise() {
  63. return "Praise the Lord!";
  64. }
  65. @Action("say")
  66. public String say() throws ApplicationException {
  67. if (null != getContext().getAttribute("--words"))
  68. return getContext().getAttribute("--words").toString();
  69. throw new ApplicationException("Could not find the parameter <i>words</i>.");
  70. }
  71. @Action("say")
  72. public String say(String words) {
  73. return words;
  74. }
  75. @Action(value = "hello", mode = Mode.HTTP_GET)
  76. public String helloGet() {
  77. return "GET";
  78. }
  79. @Action(value = "hello", mode = Mode.HTTP_POST)
  80. public String helloPost() {
  81. return "POST";
  82. }
  83. }
  84. ```
  85. Smalltalk: <a href="https://github.com/tinystruct/smalltalk">https://github.com/tinystruct/smalltalk</a>
  86. Execute in CLI mode
  87. --
  88. ```tcsh
  89. $ bin/dispatcher --version
  90. _/ ' _ _/ _ _ _/
  91. / / /) (/ _) / / (/ ( / 1.7.38
  92. /
  93. ```
  94. ```tcsh
  95. $ bin/dispatcher --help
  96. Usage: bin/dispatcher COMMAND [OPTIONS]
  97. A command line tool for tinystruct framework
  98. Commands:
  99. download Download a resource from other servers
  100. exec To execute native command(s)
  101. generate POJO object generator
  102. install Install a package
  103. maven-wrapper Extract Maven Wrapper
  104. open Start a default browser to open the specific URL
  105. say Output words
  106. set Set system property
  107. sql-execute Executes the given SQL statement, which may be an INSERT, UPDATE, DELETE, or DDL statement
  108. sql-query Executes the given SQL statement, which returns a single ResultSet object
  109. update Update for latest version
  110. Options:
  111. --allow-remote-access Allow to be accessed remotely
  112. --help Help command
  113. --host Host name / IP
  114. --import Import application
  115. --logo Print logo
  116. --settings Print settings
  117. --version Print version
  118. Run 'bin/dispatcher COMMAND --help' for more information on a command.
  119. ```
  120. ```tcsh
  121. $ bin/dispatcher say/"Praise the Lord"
  122. Praise the Lord
  123. ```
  124. ```tcsh
  125. $ bin/dispatcher say --words Hello --import tinystruct.examples.example
  126. Hello
  127. ```
  128. Run it in a http server
  129. --
  130. ```tcsh
  131. # bin/dispatcher start --import org.tinystruct.system.HttpServer
  132. ```
  133. You can access the below URLs:
  134. * <a href="http://localhost:8080/?q=say/Praise%20to%20the%20Lord!">http://localhost:8080/?q=say/Praise%20to%20the%20Lord! </a>
  135. * <a href="http://localhost:8080/?q=praise">http://localhost:8080/?q=praise</a>
  136. Performance Test
  137. --
  138. ```tcsh
  139. $ wrk -t12 -c400 -d30s "http://127.0.0.1:8080/?q=say/Praise the Lord!"
  140. Running 30s test @ http://127.0.0.1:8080/?q=say/Praise the Lord!
  141. 12 threads and 400 connections
  142. Thread Stats Avg Stdev Max +/- Stdev
  143. Latency 17.44ms 33.42ms 377.73ms 88.98%
  144. Req/Sec 7.27k 1.66k 13.55k 69.94%
  145. 2604473 requests in 30.02s, 524.09MB read
  146. Requests/sec: 86753.98
  147. Transfer/sec: 17.46MB
  148. ```
  149. Handling over **86,000** requests per second with low average latency (~17.44ms), indicating the endpoint is highly efficient under heavy load. this shows the raw power and efficiency of the **tinystruct framework**. But it's not just about the performance numbers. It's about the **philosophy** behind it.
  150. ### What makes tinystruct framework modern?
  151. 1. **No `main()` method required**
  152. Applications can be started directly using CLI commands like `bin/dispatcher`, with no boilerplate code needed. This removes unnecessary ceremony from the development lifecycle.
  153. 2. **Unified design for CLI and Web**
  154. Unlike Spring Boot which is primarily web-centric, **tinystruct** treats CLI and Web as equal citizens. This makes it perfect for AI tasks, script automation, and hybrid applications — all from the same codebase.
  155. 3. **Built-in lightweight HTTP server**
  156. Whether it’s Netty or Tomcat, tinystruct integrates the server lifecycle inside the framework. There's no need for separate containers or complicated configuration files. Just import what you need and run.
  157. 4. **Minimal configuration philosophy**
  158. Configuration is minimized to the essentials. You don't need to wire up hundreds of beans, and there's no excessive XML or YAML involved. This improves developer productivity and reduces bugs.
  159. 5. **Annotation-based routing**
  160. The framework provides a clean and intuitive routing mechanism using `@Action`, eliminating the need for overly complex controller hierarchies.
  161. 6. **Performance-first architecture**
  162. There’s almost zero overhead. No reflection-based bean scanning, no auto-wiring maze, no unnecessary interceptors unless explicitly enabled. This translates into faster response times and smaller memory footprint.
  163. 7. **Developer empowerment without complexity**
  164. With tinystruct, developers are free to focus on **real business logic** rather than fighting with framework mechanics. It's designed to be **transparent**, **predictable**, and **extensible** — all without sacrificing control or performance.
  165. ---
  166. Architecture
  167. --
  168. ![tinystruct-framework-architecture](https://github.com/user-attachments/assets/33dbdc21-4803-4b94-bf69-bee053cf558d)
  169. License
  170. --
  171. Licensed under the Apache License, Version 2.0 (the "License");
  172. you may not use this file except in compliance with the License.
  173. You may obtain a copy of the License at
  174. http://www.apache.org/licenses/LICENSE-2.0
  175. Unless required by applicable law or agreed to in writing, software
  176. distributed under the License is distributed on an "AS IS" BASIS,
  177. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  178. See the License for the specific language governing permissions and
  179. limitations under the License.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.