{"id":37028326,"url":"https://github.com/smartbuf/smartbuf-java","last_synced_at":"2026-01-14T03:22:59.757Z","repository":{"id":44729463,"uuid":"176930281","full_name":"smartbuf/smartbuf-java","owner":"smartbuf","description":"SmartBuf is a cross-language serialization and deserialization framework, and it has         high performance and compression ratio like protobuf, high compatibility and scalability like json.","archived":false,"fork":false,"pushed_at":"2023-12-05T22:21:02.000Z","size":2819,"stargazers_count":11,"open_issues_count":4,"forks_count":3,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-07-23T07:51:30.836Z","etag":null,"topics":["cross-language-serialization","deserialization-framework","serialization","serialization-library"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/smartbuf.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2019-03-21T11:22:35.000Z","updated_at":"2022-11-23T02:48:15.000Z","dependencies_parsed_at":"2022-09-13T19:01:10.276Z","dependency_job_id":null,"html_url":"https://github.com/smartbuf/smartbuf-java","commit_stats":null,"previous_names":["sisyphsu/smartbuf"],"tags_count":4,"template":false,"template_full_name":null,"purl":"pkg:github/smartbuf/smartbuf-java","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/smartbuf%2Fsmartbuf-java","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/smartbuf%2Fsmartbuf-java/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/smartbuf%2Fsmartbuf-java/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/smartbuf%2Fsmartbuf-java/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/smartbuf","download_url":"https://codeload.github.com/smartbuf/smartbuf-java/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/smartbuf%2Fsmartbuf-java/sbom","scorecard":{"id":827970,"data":{"date":"2025-08-11","repo":{"name":"github.com/smartbuf/smartbuf-java","commit":"c069efc25b376852e377bf4d83d8637d9b354ef6"},"scorecard":{"version":"v5.2.1-40-gf6ed084d","commit":"f6ed084d17c9236477efd66e5b258b9d4cc7b389"},"score":3.1,"checks":[{"name":"Token-Permissions","score":0,"reason":"detected GitHub workflow tokens with excessive permissions","details":["Warn: no topLevel permission defined: .github/workflows/maven.yml:1","Info: no jobLevel write permissions found"],"documentation":{"short":"Determines if the project's workflows follow the principle of least privilege.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#token-permissions"}},{"name":"Code-Review","score":0,"reason":"Found 1/25 approved changesets -- score normalized to 0","details":null,"documentation":{"short":"Determines if the project requires human code review before pull requests (aka merge requests) are merged.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#code-review"}},{"name":"Dangerous-Workflow","score":10,"reason":"no dangerous workflow patterns detected","details":null,"documentation":{"short":"Determines if the project's GitHub Action workflows avoid dangerous patterns.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#dangerous-workflow"}},{"name":"Packaging","score":-1,"reason":"packaging workflow not detected","details":["Warn: no GitHub/GitLab publishing workflow detected."],"documentation":{"short":"Determines if the project is published as a package that others can easily download, install, easily update, and uninstall.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#packaging"}},{"name":"CII-Best-Practices","score":0,"reason":"no effort to earn an OpenSSF best practices badge detected","details":null,"documentation":{"short":"Determines if the project has an OpenSSF (formerly CII) Best Practices Badge.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#cii-best-practices"}},{"name":"Maintained","score":0,"reason":"0 commit(s) and 0 issue activity found in the last 90 days -- score normalized to 0","details":null,"documentation":{"short":"Determines if the project is \"actively maintained\".","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#maintained"}},{"name":"Binary-Artifacts","score":10,"reason":"no binaries found in the repo","details":null,"documentation":{"short":"Determines if the project has generated executable (binary) artifacts in the source repository.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#binary-artifacts"}},{"name":"Security-Policy","score":0,"reason":"security policy file not detected","details":["Warn: no security policy file detected","Warn: no security file to analyze","Warn: no security file to analyze","Warn: no security file to analyze"],"documentation":{"short":"Determines if the project has published a security policy.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#security-policy"}},{"name":"Pinned-Dependencies","score":0,"reason":"dependency not pinned by hash detected -- score normalized to 0","details":["Warn: GitHub-owned GitHubAction not pinned by hash: .github/workflows/maven.yml:14: update your workflow using https://app.stepsecurity.io/secureworkflow/smartbuf/smartbuf-java/maven.yml/master?enable=pin","Warn: GitHub-owned GitHubAction not pinned by hash: .github/workflows/maven.yml:16: update your workflow using https://app.stepsecurity.io/secureworkflow/smartbuf/smartbuf-java/maven.yml/master?enable=pin","Info:   0 out of   2 GitHub-owned GitHubAction dependencies pinned"],"documentation":{"short":"Determines if the project has declared and pinned the dependencies of its build process.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#pinned-dependencies"}},{"name":"Fuzzing","score":0,"reason":"project is not fuzzed","details":["Warn: no fuzzer integrations found"],"documentation":{"short":"Determines if the project uses fuzzing.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#fuzzing"}},{"name":"License","score":10,"reason":"license file detected","details":["Info: project has a license file: LICENSE:0","Info: FSF or OSI recognized license: Apache License 2.0: LICENSE:0"],"documentation":{"short":"Determines if the project has defined a license.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#license"}},{"name":"Signed-Releases","score":-1,"reason":"no releases found","details":null,"documentation":{"short":"Determines if the project cryptographically signs release artifacts.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#signed-releases"}},{"name":"Branch-Protection","score":0,"reason":"branch protection not enabled on development/release branches","details":["Warn: branch protection not enabled for branch 'master'","Warn: branch protection not enabled for branch 'v0.1.1'"],"documentation":{"short":"Determines if the default and release branches are protected with GitHub's branch protection settings.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#branch-protection"}},{"name":"SAST","score":0,"reason":"SAST tool is not run on all commits -- score normalized to 0","details":["Warn: 0 commits out of 6 are checked with a SAST tool"],"documentation":{"short":"Determines if the project uses static code analysis.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#sast"}},{"name":"Vulnerabilities","score":6,"reason":"4 existing vulnerabilities detected","details":["Warn: Project is vulnerable to: GHSA-vmq6-5m68-f53m","Warn: Project is vulnerable to: GHSA-668q-qrv7-99fm","Warn: Project is vulnerable to: GHSA-6v67-2wr5-gvf4","Warn: Project is vulnerable to: GHSA-pr98-23f8-jwxv"],"documentation":{"short":"Determines if the project has open, known unfixed vulnerabilities.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#vulnerabilities"}}]},"last_synced_at":"2025-08-23T16:59:22.547Z","repository_id":44729463,"created_at":"2025-08-23T16:59:22.547Z","updated_at":"2025-08-23T16:59:22.547Z"},"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28408828,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-14T01:52:23.358Z","status":"online","status_checked_at":"2026-01-14T02:00:06.678Z","response_time":107,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cross-language-serialization","deserialization-framework","serialization","serialization-library"],"created_at":"2026-01-14T03:22:59.172Z","updated_at":"2026-01-14T03:22:59.737Z","avatar_url":"https://github.com/smartbuf.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# SmartBuf [![Travis CI](https://travis-ci.org/smartbuf/smartbuf-java.svg?branch=master)](https://travis-ci.org/smartbuf/smartbuf-java) [![codecov](https://codecov.io/gh/smartbuf/smartbuf-java/branch/master/graph/badge.svg)](https://codecov.io/gh/smartbuf/smartbuf-java)\n\n[中文文档](./doc/index_zh.md)\n\n`smartbuf` is a cross-language serialization and deserialization framework, \nwhich has high performance and compression ratio like `protobuf`, and has high compatibility and scalability like `json`.\n\nLike `json`, encoded-data generated by `smartbuf` still keeps the `schema` infomation, \nwithout any pre-defined `IDL`, receiver could decode it directly. \nThis feature makes `smartbuf` have better scalability, compatibility and universality.\n\nIn order to improve the efficiency of compression and transmission, `smartbuf` uses **Partition Serialization** strategy.\nIt will split object into multiple different parts, and use different method to encode them. \nAbout the details, please refer to the following **Partition Serialization** section. \n\nBecause of the well-designed **Partition Serialization** strategy, `smartbuf` provides higher compression ratio and performance.\nIn my benchmarks, it even could be better than `protobuf`.\nFor more details, please refer to the following **Benchmark** section.\n\n`smartbuf` also provides two different modes named `packet` and `stream` for different scenes.\nFor more details, please refer to the following **Usage** section.\n\n# Partition Serialization\n\nIn the design concept of `smartbuf`, objects are consists of the following three parts:\n\n+ `property`: it's the underlying property of object's fields, like number, float, string, etc.\n+ `struct`: it describes object's structure, includes field-name and fields.\n+ `body`：it represents normal object, but all `property` and `struct` are referenced from previous two parts.\n\nFor this concept, `smartbuf` creates **Partition Serialization** strategy.\nThat is, during object encoding process, different parts will be encoded into independent partitions, \nthereby forming multiple compact partitions, and each partition is associated by unique `ID` to complete the assembly of objects.  \n\n## `property` Partition\n\nProperty Partition is responsible for storing standard and common values, \nlike `const`, `float`, `double`, `varint`, `string`, `symbol`, etc.\n\nIt also allocate unique `ID` for those values, in other partitions, only need **1~2** bytes to reference those values. \n\nIn the real world, some properties could be repeated in objects, especially for array or collection.\nIn this case, if use `json` and `protobuf`, the repeated data will be re-serialized again and again.\nBut for `smartbuf`, thanks to the partition design, it's unnecessary at all, which could significantly improves space utilization.  \n\n## `struct` Partition\n\nIn the design of `smartbuf`, `struct` represents a field-name-list, it doesn't care every field's data type.\n\nStruct Partition contains two parts: `field-name` pool and `struct` pool, the former is similar with `string[]`,\nthe latter is similar with `int[][]`，which means `int[]` could represents an `struct`, \nand each `int` represents the reference to a field name.\n\nThis design has two advantages:\n\n + **Field Name Reusing**: While encoding, different objects could reuse same field names, especially for common name like `name`, `id`, `timestamp`, `url`, etc.\n + **Context Reusing**：Could easily cache and reuse the global `struct` partition.\n\nIn fact, `smartbuf` will keep two `struct` pools inside, namely `temporary` and `context`.\nthe former used to describe some temporary object like `Map`, and the latter used to describe some reusable object like `POJO`.\n\nThis is also the biggest difference between the `packet` and `stream` modes mentioned earlier. \nFor `packet` mode, the context concept is disabled, it will treat all objects as `temporary` types.\n\n## Data Partition\n\nData Partition is mainly the `body`.\n\nAs mentioned above, the object's `property` and `struct` have been extracted into seperate partitions.\nTherefore, `body` could use very small space to reference `property` and `struct`, thus assembling into a complete object. \n\nThe above rules are mainly for ordinary `object`, and for array there has a special set of processing rules:\n\n + **Native Array**: Native Array as one special entity, wouldn't be extracted into `property`.\n + **Slice Array**: Some complex `object[]` may contains different data, even `null`, so `smartbuf` will treat one array as multiple slices which has same data type. \n\n`smartbuf` has a very clever algorithm for the processing of arrays, which can improve the coding space utilization.\n\n## Partition Example\n\nFor better understanding of Partition Serialization, \nthis section demonstrates the details of the partition encoding described above with a simple object.\n\nThis is a simple `User` model:\n\n```proto\nmessage User {\n    int32 id = 1;\n    string name = 2;\n    int64 time = 3;\n}\n```\n\nFor the first time to use `smartbuf` to encode `User{id=1001, name=\"hello\", time=10000L}`, the final output bytecode is as follows:\n\n![smartbuf-first-packet](./doc/img/smartbuf-packet.png)\n\nBecause the first output contains `schema` data of `User`, so it appears to be bloated.  \n\nIf in `stream` mode to encode it again, some `schema` will be reused, and the final output bytecode is as follows:\n\n![smartbuf-following](./doc/img/smartbuf-stream.png)\n\nIn real system development, the data we transformed \n\nAs you can imagine, in actual system development, there are often many repetitive properties inside the data we transmit\n (especially arrays). Serializing these repeated attributes with `smartbuf` often requires only one extra byte.\n\nIn addition, as can be seen from this example, even for anyone who does not cache the full context `schema` metadata,\nthe message can be parsed normally.\nOf course, due to the lack of auxiliary field information in the data body, \nthe field names `id`, `name`, `time` cannot be parsed normally, and they can only be parsed into meaningless serial numbers.\n\nThis feature is very helpful for data readability and debugability. \nYou can capture packets through the network, and directly view the encoded data message of `smartbuf`, \nwhich is very difficult for `protobuf`.\n\n# Usage\n\nBy now, `smartbuf` only support `java` language, we are working on its support for `javascript`, `golang`, etc.\n\nYou can install `smartbuf` by this maven dependency:\n\n```xml\n\u003cdependency\u003e\n  \u003cgroupId\u003ecom.github.smartbuf\u003c/groupId\u003e\n  \u003cartifactId\u003esmartbuf\u003c/artifactId\u003e\n  \u003cversion\u003e0.1.4\u003c/version\u003e\n\u003c/dependency\u003e\n```\n\nAs mentioned above, `smartbuf` supports two modes: `packet` and `stream`, \nwhich are wrapped in `SmartPacket` and `SmartStream` respectively, the following is their usages.\n\n## [`SmartPacket`](https://github.com/smartbuf/smartbuf-java/blob/master/src/main/java/com/github/smartbuf/SmartPacket.java)\n\n`SmartPacket` encapsulates `smartbuf` support for `packet` mode, it's a static utility class, \nwhich could be used directly without initialization.  \n\n```java\nUserModel user = new UserModel(1001, \"hello\", 10000L);\nbyte[] bytes = SmartPacket.serialize(user); // serialize or encode\nUserModel newUser = SmartPacket.deserialize(bytes, UserModel.class); // deserialize or decode\nassert user.equals(newUser); \n```\n\nIn `packet` mode, `smartbuf` is very similar with `json`, encoded bytecodes contains the whole `schema` information. \nThe only difference is that `smartbuf` has much higher performance and higher compression ratio.\n\nThe underlying `encode` and `decode` implementation of `smartbuf` are not thread-safe, \nso `SmartPacket` internally encapsulates a reusable instance via `ThreadLocal`, \nFor more details, please refer to its source code.   \n\n## [`SmartStream`](https://github.com/smartbuf/smartbuf-java/blob/master/src/main/java/com/github/smartbuf/SmartStream.java)\n\n`SmartStream` encapsulates the `stream` mode support for `smartbuf`. Before using it, you should construct a new instance manually:\n\n```java\nfinal SmartStream stream = new SmartStream();\nUserModel user = new UserModel(1001, \"hello\", 10000L);\nbyte[] bytes = stream.serialize(user); // serialize or encode \nUserModel newUser = stream.deserialize(bytes, UserModel.class);  // deserialize or decode\nassert user.equals(newUser);\n```\n\nIn `stream` mode, the context status is very important for `smartbuf`.\nThe `serialize` will only encode `schema` once, and the `deserialize` will keep the received `schema` for context reusing. \n\nRemember, `SmartStream` isn't thread-safe, you need to construct a seperate instance for each session `context` or `socket` connection,\nand ensure that each bytecode packet is processed through it orderly.  \n\nDiscontinuous packet my cause context `schema` confusion. \nTo avoid this situation, `serialize` will attach an small sequence number into `stream` packets, \nand `deserialize` will check the `sequence`'s continuity as need.   \n\n## Comparison of `packet` and `stream`\n\nThe `packet` mode has a relatively low serialization compression ratio. \nIt needs to attach complete metadata information to each data message, \nwhich is more suitable for a contextless scenario like api request.\n\nThe `stream` mode has a higher serialization compression ratio. In most scenarios, it is higher than `protobuf`. \nIt needs to maintain the context state at both ends of the data transmission, \nwhich is more suitable for scenarios like long-connection multiplexing.\n\n# Benchmark\n\nThis section is mainly for a comprehensive performance benchmark test for various data scenarios. \nThe data magnitude includes `small`, `medium`, `large`, and the comparison tests include:\n\n+ `json`: The technical solution used in the test is `jackson`, which is also the best library for `json` serialization performance in the `java` language.\n+ `kryo`: It only supports `java`, including it into the test is only for horizontal comparison.\n+ `msgpack`: It's similar to `json`, but it performs poorly in actual tests and only for observational references.\n+ `protobuf`: In the following performance test, it is an important challenge for `smartbuf`.\n\nThe performance test uses `JMH` technology, which handles `warmup` well, \nand also supports very accurate statistics of various performance indicators. \nThe test environment is as follows:\n\n + JDK 1.8.0_191\n + MacBook Pro (15-inch, 2018)\n\nThe source code of this benchmark is [`test`](https://github.com/smartbuf/smartbuf-java/tree/master/src/test/java/com/github/smartbuf/benchmark).\nYou could `checkout` it and run it locally.\n \n## `Small` Object\n\nThe first object to be tested is a small `User` instance, which is not the actual data model used in any production environment. \nIt is only used to demonstrate the performance of `smartbuf` on minimal object serialization. The specific model is as follows:\n\n```java\npublic class UserModel {\n    private long    id;\n    private Boolean blocked;\n    private String  nickname;\n    private String  portrait;\n    private float   score;\n    private int     loginTimes;\n    private long    createTime;\n}\n```\n\nThe benchmark result is as follows:\n\n![small](./doc/img/small.png)\n\nDue to the special partition serialization strategy, \n`smartbuf` does not perform as well as `protobuf` when dealing with small objects, \nbut it has obvious advantages over `json`.\n\n## `Medium` Object\n\nThe next object to be tested is a fragment extracted from our production environment data structure. \nThe specific model is as follows:\n\n```java\npublic class UserModel {\n    private long    id;\n    private String  nickname;\n    private String  portrait;\n    private float   score;\n    private String  mail;\n    private String  mobile;\n    private String  token;\n    private Integer type;\n    private Integer source;\n    private Boolean blocked;\n    private int     loginTimes;\n    private long    updateTime;\n    private long    createTime;\n    \n    private List\u003cMessage\u003e msgs;\n    private List\u003cTag\u003e     tags;\n\n    public static class Message {\n        private Long   id;\n        private Long   from;\n        private Long   to;\n        private String msg;\n        private Long   timestamp;\n    }\n\n    public static class Tag {\n        private int    code;\n        private String name;\n    }\n}\n```\n\nIn the test preparation data, several small objects are randomly allocated for `msgs` and `tags` respectively, \nand finally the performance of each serialization framework is as follows:\n\n![medium](./doc/img/medium.png)\n\nIt can be seen that during the serialization process of this data magnitude, \n`smartbuf` using `stream` mode exceeds `protobuf`, however, due to the pre-compilation of `protobuf`, \nits encoding and decoding performance still has obvious advantages.\n\n## `Large` Object\n\nThe previous `small` and `medium` are not the actual data used in any production environment. \nIn order to test its performance in the real production environment, this section deliberately took a famous `APP` for testing.\n\nThe test data is taken from the `Twitter` web version of the home page sidebar **global trend**, \nwhich is probably one of the most frequently used interfaces, \ni have organized it into [`json`](https://github.com/smartbuf/smartbuf-java/blob/master/src/test/resources/large.json).\nThe corresponding `java` model is too large, you can see the source code \n[`TrendModel`](https://github.com/smartbuf/smartbuf-java/blob/master/src/test/java/com/github/smartbuf/benchmark/large/TrendModel.java).\n\nFor this test data, the performance of each serialization framework is as follows:\n\n![large](./doc/img/large.png)\n\nAs we can see, the over `64KB` of global trend data, only need `20KB` for `smartbuf` encoding, \neven the `packet` mode is significantly better than `protobuf`.\n\nThe encoding performance is also the best of `smartbuf`, but `protobuf` still has a big lead in decoding performance.\n\n# Advantages and disadvantages\n\nFrom the above examples and tests, \nwe can intuitively see that `smartbuf` keeps the `schema` information in the serialization result.\nThis makes it difficult to take advantage of design when it comes to small data sets, \nespecially for test small objects around `100B`.\n\nBut for normal data objects, such as the common system data such as `2K`, `20K`, even bigger,\nthe advantages of the `smartbuf` algorithm design can be fully reflected.\nFor larger data objects of the array class, the space utilization of `smartbuf` will significantly exceed `protobuf`.\n\nUsing `smartbuf` does not need to predefine any `IDL` like `*.proto`, \nit can directly encode the ordinary `POJO` as `byte[]`. \nThe whole process is very similar to the commonly used `json` serialization tool.\n\nAll in all, using `smartbuf` may bring the following benefits:\n\n## More efficient data transfer\n\nCompared to `json`, it can reduce network resource consumption by even 70%.\n\nCompared to `protobuf`, it can also reduce network resource consumption by over 10%.\n\nFor Internet products, especially the mobile Internet that network isn't stable,\nit can improve the interface response speed, reduce the power consumption of the device, and improve the system throughput.\n\n## Improve development and debugging flexibility\n\nCompared to `protobuf`, using `smartbuf` no longer requires manual maintenance of `IDL`, \nwhich is very important for fast iterations of early productions.\n\nAnother point that can't be ignored is the impact of `IDL` on the product.\nFor example, I participated a `Android` application that uses `protobuf`,\nwith the rapid iteration, the `proto` was frequently modified. \nAfter the product went online one year later, the `jar` package compiled by `proto` even reached an amazing `3.8MB`, \nbut the whole `APP` was less than 12MB.\n\n# Description\n\nAny form of technical discussion, problem feedback, assistance in development, etc. are welcome.\n\n`smartbuf` is a novel technology that is currently only available in a small range.\nBut every line of code and every logic has been thoroughly tested, \nand the test coverage of `100%` may not be enough to cover all the scenarios in the actual product reference.\n\nIf you encounter any problems during the actual using, please submit the `issue` feedback in time, \nwe will respond as soon as possible.\n\nLet us know if you like it, it could encourage us keep working~~\n\n# License\n\nApache-2.0\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsmartbuf%2Fsmartbuf-java","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fsmartbuf%2Fsmartbuf-java","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsmartbuf%2Fsmartbuf-java/lists"}