cysharp / memorypack Goto Github PK
View Code? Open in Web Editor NEWZero encoding extreme performance binary serializer for C# and Unity.
License: MIT License
Zero encoding extreme performance binary serializer for C# and Unity.
License: MIT License
MEMPACK019 The MemoryPackable object 'ConfigDictionary' member 'Comparer' type 'global::System.Collections.Generic.IEqualityComparer' is not MemoryPackable. Annotate [MemoryPackable] to 'global::System.Collections.Generic.IEqualityComparer' or if external type that can serialize, annotate [MemoryPackAllowSerialize]
to member ....
"Comparer" seems a protected member of Dictionary or ConcurrentDictionary.
[MemoryPackable]
public partial class ConfigDictionary<T> : Dictionary<string, T>
{
}
Currently tuple is serialized:
Shouldn't we have a type that is serialized as a continuous value with no object header?
Already added BitPackFormatter
, BrotliFormatter
.
We can add other compression algorithms.
https://www.timescale.com/blog/time-series-compression-algorithms-explained/
https://github.com/apache/parquet-format/blob/master/Encodings.md
https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html
https://takuya-a.net/blog/inverted-index-compression-techniques/
Currently only support byte
.
add ushort
,or uint
tag support.
Will there be integration with MagicOnion?
I would like to see an example in ASP Net with zero allocation for objects of a value type, for example structures.
Suggest: MemoryPackUnion(Type type, ushort? tag=null )]
if null, code generator assign the tag for each type accordingly.
I don't know why must serve this tag parameter to the the MemoryPackUnion attribute, it's boring to assign a sequence of unfriendly numbers which will not be used later to a pile of classes.
I have testet out the library, it's fantastic :)
Is there any way to control the casing of generated typescript models?
if u have a type used in a plugin (i.e. dynamically loaded assembly) while registered with [MemoryPackUnionFormatter] in the host program, the following line in in the generated code seems unable to get the Type, even The type names are same.
if (__typeToTag.TryGetValue(value.GetType(), out var tag))
this is possibly because the Type registered in __typeToTag
is not the same object with value.GetType()
, even though their FullNames and GUIDs r the same, for the former was instantiated at host launch, but the latter was instantiated when load the plugin.
is it better to use type GUID as Key?
I was impressed by how amazing this library is!!
And, even more, after seeing that TypeScript would be supported.
I don't know yet if there is a problem with the latest versions, but it looks like the generator is not generating the runtime and dependent files.
Version 1.8.6 is working as expected.
Hi, about this code:
public static byte[] Serialize<T>(in T? value, MemoryPackSerializerOptions? options = default)
{
if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
{
var array = AllocateUninitializedArray<byte>(Unsafe.SizeOf<T>());
Unsafe.WriteUnaligned(ref GetArrayDataReference(array), value);
return array;
}
I am not sure why ReusableLinkedArrayBufferWriter is not used for this case too. wouldn't this mean a certain allocation?
public partial class MyClass(int @if, ...)
in generated code:
__if = value.if;
in generated code: [System.Runtime.CompilerServices.ModuleInitializer] not available for netstandard2.1 (need 5+).
Compiler Error CS0234 The type or namespace name 'name' does not exist in the namespace 'namespace' (are you missing an assembly reference?)
in
[System.Runtime.CompilerServices.ModuleInitializer]
public static void RegisterFormatter()
It is impossible to serialize classes that are defined in external libraries, so it would be nice if you could provide the same information as MemoryPackUnion, but via a builder system instead.
From your own example. Instead of doing this:
[MemoryPackable]
[MemoryPackUnion(0, typeof(FooClass))]
[MemoryPackUnion(1, typeof(BarClass))]
public partial interface IUnionSample { }
[MemoryPackable]
public partial class FooClass : IUnionSample { }
[MemoryPackable]
public partial class BarClass : IUnionSample { }
It would be nice to do this:
These 3 classes are provided by an external library that can't take a dependency on MemoryPack. so they look like this (in the library):
public interface IUnionSample { }
public class FooClass : IUnionSample { }
public class BarClass : IUnionSample { }
Since they are not partial, we can't use source generator etc. - instead we create a custom formatter. But in order to support union/polymorphism, we need to provide the inheritance relationships somehow. It could be done like this:
UnionBuilder ub = new UnionBuilder(typeof(IUnionSample));
ub.AddUnion(0, typeof(FooClass));
ub.AddUnion(1, typeof(BarClass));
//Then we provide 'ub' to the serializer in some way.
Note that I just come up with an example on the spot. I have no preference for how the above is achieved.
I don't see anything wrong with the names, according to following requirement:
MEMPACK006 The MemoryPackable object 'Man' constructor's all parameters must match serialized member name(case-insensitive)
[MemoryPackable]
public partial class Man : AbstractMan
{
public Man(IServer refServer, string hostServerEui)
{
RefServer = refServer;
HostServerEui = hostServerEui;
}
}
Hi,
This looks great and congrats on the new library. It's clear you've been using this library in Unity projects so I hope there is a simple answer here: If one uses Newtonsoft .NET JSON serializer in a Unity project you typically have to define some custom contracts to properly serialize various Unity structs and classes that are common to add to serialized data. For example an AnimationCurve
.
Does MemoryPack have a similar ability to mark up or write contracts for external C# structures that we cannot access?
I have various Types defined in 3 libs, namely Model, Man, Config, and these types are finally used in the lib: Server
i.e. Server depends on Model, Man, Config, otherwise Man and Config depends on Model.
And, All these Types inherits a single interface IMyMemoryPackable
defined in Model.
I wrote a MyMemoryPackableFormtter.cs in lib Server like this to register all these types:
[MemoryPackUnionFormatter(typeof(IMyMemoryPackable))]
[MemoryPackUnion(0, typeof(Type1))]
[MemoryPackUnion(1, typeof(Type2))]
[MemoryPackUnion(2, typeof(Type3))]
public partial class MyMemoryPackableFormatter
{
}
but compiler yields:
Server (net7.0) :
compiling error: CS8987 The ‘scoped’ modifier of parameter ‘value’ doesn’t match overridden or implemented member
However,
if i split this MyMemoryPackableFormatter
into three separate Formatters(note all these formatters register for the same interface, namely IMyMemoryPackable
) into three libs (no matter their names r the same or not), the compiler compiles OK and the program can launch, but the generated code seems only to use one Formatter to do serialize Job (other Types cannot be found ).
The HostOptions.BackgroundServiceExceptionBehavior is configured to StopHost. A BackgroundService has thrown an unhandled exception, and the IHost instance is stopping. To avoid this behavior, configure this to Ignore; however the BackgroundService will not be restarted. System.TypeLoadException: Virtual static method 'Serialize' is not implemented on type 'SystemModule.Packets.ServerPackets.ServerDataMessage' from assembly 'SystemModule, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null'.
Hi, the Version tolerant section mentions that
MemoryPackable objects, members can be added, but not deleted
I'm trying to use MemoryPack for RPC between two sides that should support different versions.
If I add a property to one side, serialize it, and send it to the other side which doesn't have the added property yet, deserialization crashes in MemoryPackSerializationException.ThrowInvalidPropertyCount
.
It's a bit confusing, because technically I added a property, but for the deserializer it's as if I deleted it, which is not supported. Would it be possible to ignore deleted properties?
Hello,
I am trying to write a c# console app client for the SandboxWebApp using HttpClient, but so far i have no been sucessful.
How can i use the HttpClient for calling this endpoint?
This is the code for my console app that I am testing:
using MemoryPack;
TestModel value = new() { Id = Guid.NewGuid(), Name = "Test" };
var bin = MemoryPackSerializer.Serialize(value);
HttpClient httpClient = new();
HttpRequestMessage request = new() {
Content = new ByteArrayContent(bin),
RequestUri= new Uri("http://localhost:5173"),
Method= HttpMethod.Post
};
request.Headers.TryAddWithoutValidation("Content-Type", "application/x-memorypack");
var response = await httpClient.SendAsync(request);
[MemoryPackable]
public partial class TestModel
{
public Guid Id { get; set; }
public string? Name { get; set; }
}
I propose new overloads for Serialize
and Deserialize
which operate on a Span<Byte>
and ReadOnlySpan<T>
, respectively.
Additionally, a new method would be required which returns the calculated size of the serialized object. Something like GetSerializedByteLength
.
Together, it would enable zero-allocation serialization on the stack like this:
const int maxStackAllocSize = 4096;
var length = MemoryPackSerializer.GetSerializedByteLength(v);
Span<byte> buf = length <= maxStackAllocSize ? stackalloc Byte[length] : new Byte[length];
MemoryPackSerializer.Serialize(v, buf);
var val = MemoryPackSerializer.Deserialize<Person>(bin, buf);
I'm testing MemoryPack (latest .NET 7) with a class that has multiple constructors, and I marked one of the constructors as '[MemoryPackConstructor]'.
However, the project doesn't compile and shows an error during compilation:
"Error CS0234 The type or namespace name 'Formatters' does not exist in the namespace 'Tests.MemoryPack' (are you missing an assembly reference?)"
And it points to line 44 in generated code:
Here is my full test code:
using MemoryPack;
namespace Tests.MemoryPack
{
[MemoryPackable]
public partial class TestObject
{
public string testString { get; set; } = "";
[MemoryPackConstructor]
public TestObject() { }
public TestObject(string ignore) { }
}
class MemPackTest
{
public static void Main()
{
TestObject test_object = new();
test_object.testString = "ABC";
Console.WriteLine("Initial value before serializing: " + test_object.testString);
byte[] serialized_object = MemoryPackSerializer.Serialize(test_object);
TestObject? deserialized_object = MemoryPackSerializer.Deserialize<TestObject>(serialized_object);
if (deserialized_object != null)
{
Console.WriteLine("Final value after deserializing: " + deserialized_object.testString);
}
Console.WriteLine("Test completed. Press any key to exit");
Console.ReadKey();
}
}
}
I executed the following code on an IL2CPP built Android app and got an exception.
I built the app with Unity 2021.3.6f1, and executed it on Pixel 4a(Android) & iPhoneX(iOS).
Managed stripping code level set to minimal.
// List<T> case
var list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);
var bin = MemoryPackSerializer.Serialize(list); // Caught an exception here.
var val = MemoryPackSerializer.Deserialize<List<int>>(bin);
Autoconnected Player "Autoconnected Player" ExecutionEngineException: Attempting to call method 'MemoryPack.Formatters.UnmanagedFormatter`1<System.Int32>::Serialize<MemoryPack.Internal.ReusableLinkedArrayBufferWriter>' for which no ahead of time (AOT) code was generated. Consider increasing the --generic-virtual-method-iterations=1 argument
at MemoryPack.Formatters.ListFormatter`1[T].Serialize[TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, System.Collections.Generic.List`1[T]& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T,TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, T& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T] (T& value, MemoryPack.MemoryPackSerializeOptions options) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPackCheck.Start () [0x00000] in <00000000000000000000000000000000>:0
MemoryPackCheck:Start()
// Dictionary<K,V> case
var dict = new Dictionary<int, string>();
dict[1] = "one";
dict[2] = "two";
dict[3] = "three";
var bin = MemoryPackSerializer.Serialize(dict); // Caught an exception here.
var val = MemoryPackSerializer.Deserialize<Dictionary<int, string>>(bin);
Autoconnected Player "Autoconnected Player" ExecutionEngineException: Attempting to call method 'MemoryPack.Formatters.KeyValuePairFormatter`2<System.Int32, System.String>::Serialize<MemoryPack.Internal.ReusableLinkedArrayBufferWriter>' for which no ahead of time (AOT) code was generated. Consider increasing the --generic-virtual-method-iterations=1 argument
at MemoryPack.Formatters.DictionaryFormatter`2[TKey,TValue].Serialize[TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, System.Collections.Generic.Dictionary`2[TKey,TValue]& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T,TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, T& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T] (T& value, MemoryPack.MemoryPackSerializeOptions options) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPackCheck.Start () [0x00000] in <00000000000000000000000000000000>:0
MemoryPackCheck:Start()
// List<T> property case
[MemoryPackable]
public partial class MyContainer2
{
public List<int> List = new List<int>();
}
var container = new MyContainer2();
container.List.Add(1);
container.List.Add(2);
container.List.Add(3);
var bin = MemoryPackSerializer.Serialize(container); // Caught an exception here.
var val = MemoryPackSerializer.Deserialize<MyContainer2>(bin);
Autoconnected Player "Autoconnected Player" ExecutionEngineException: Attempting to call method 'MemoryPack.Formatters.UnmanagedFormatter`1<System.Int32>::Serialize<MemoryPack.Internal.ReusableLinkedArrayBufferWriter>' for which no ahead of time (AOT) code was generated. Consider increasing the --generic-virtual-method-iterations=1 argument
at MemoryPack.Formatters.ListFormatter`1[T].Serialize[TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, System.Collections.Generic.List`1[T]& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T,TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, T& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T] (T& value, MemoryPack.MemoryPackSerializeOptions options) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPackCheck.Start () [0x00000] in <00000000000000000000000000000000>:0
MemoryPackCheck:Start()
// Dictionary<K,V> property case
[MemoryPackable]
public partial class MyContainer
{
public Dictionary<int, string> Dict = new Dictionary<int, string>();
}
var container = new MyContainer();
container.Dict[1] = "One";
container.Dict[2] = "Two";
container.Dict[3] = "Three";
var bin = MemoryPackSerializer.Serialize(container); // Caught an exception here.
var val = MemoryPackSerializer.Deserialize<MyContainer>(bin);
Autoconnected Player "Autoconnected Player" ExecutionEngineException: Attempting to call method 'MemoryPack.Formatters.KeyValuePairFormatter`2<System.Int32, System.String>::Serialize<MemoryPack.Internal.ReusableLinkedArrayBufferWriter>' for which no ahead of time (AOT) code was generated. Consider increasing the --generic-virtual-method-iterations=1 argument
at MemoryPack.Formatters.DictionaryFormatter`2[TKey,TValue].Serialize[TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, System.Collections.Generic.Dictionary`2[TKey,TValue]& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T,TBufferWriter] (MemoryPack.MemoryPackWriter`1[TBufferWriter]& writer, T& value) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPack.MemoryPackSerializer.Serialize[T] (T& value, MemoryPack.MemoryPackSerializeOptions options) [0x00000] in <00000000000000000000000000000000>:0
at MemoryPackCheck.Start () [0x00000] in <00000000000000000000000000000000>:0
MemoryPackCheck:Start()
ClassA
{
}
ClassB : ClassA
{
// ClassB may have some extra properties in addtion to ClassA
}
ClassA objectA = new();
ClassB objectB = MemoryPackSerializer.Deserialize<ClassB>(MemoryPackSerializer.Serialize(objectA));
this throws exception:
MemoryPack.MemoryPackSerializationException:“Length header size is larger than buffer size, length: 2048.
Why?
like System.Text.Json: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/preserve-references
[MemoryPackable(GenerateType.AllowCircularReference)]
It serializes like GenerateType.VersionTolerant
with id
or ref
message type flag.
CASE: I need to serialize any MemoryPackable objects using an array or colleciton but seems not possible, cos the most abstract interface IMemoryPackFormatterRegister has a static member, which can not be used as a type parameter.
I think a more abstract interface without static member could solve this problem, couldn't it?
SUGGEST:
namespace MemoryPack
{
public interface IMemoryPackFormatterRegister: IMemoryPackObject
{
static void RegisterFormatter();
}
public interface IMemoryPackObject {}
}
lexically, i prefer the name IMemoryPackable, but it was already used.
A more reasonable hierachy might be IMemoryPackObject: IMemoryPackFormatterRegister : IMemoryPackable
Hi. I just cloned the repo and tried to build with .net 7.0.100-preview.7.22377.5 and got this error:
error CS0246: The type or namespace name 'GeneratedRegexAttribute' could not be found (are you missing a using directive or an assembly reference?)
But when I replace GeneratedRegex
with RegexGenerator
It builds successfully.
AssemblyA:
[MemoryPackUnionFormatter(typeof(IPlugin))]
[MemoryPackUnion(0, typeof(Plugin1))]
[MemoryPackUnion(1, typeof(Plugin2))]
public partial class PluginFormatter
{ }
AssemblyB:
[MemoryPackUnionFormatter(typeof(IPlugin))]
[MemoryPackUnion(2, typeof(Plugin3))]
[MemoryPackUnion(3, typeof(Plugin4))]
public partial class PluginFormatter
{ }
Question: Is it possible to merge the MemoryPackUnionFormatters declared in different assemblies (like above) referencing the same interface with/without same class names?
The underlying solution might be allowing formatters for each interface be registered more than once and merge the types into one type dictionary (together with their tags) or be search through a hierachy of dicitonaries.
This solves following issue:
MemoryPackUnionFormatter must be centralized in the final consumer libs, and cannot be distributed in different assemblies, if these libs r used by different programs, each program must write their own formatter (a lot of redundency work), why can not the type registration be done by each assembly on module basis and they merge to one when compiled, while programmers can negotiate tag segments for each assembly to avoid conflicts, like 1-10 for assembly one, 20-30 for another?
Unreferenced types(with known interface) declared in plugin assembly r not applicable for MemoryPack, cos they r not pre-registered in the host program, but what if their types come as compiled with MemoryPack with code already generated?
I’m curious if supporting a lower version is possible? If we target C# 9/.NET Standard 2.1/Roslyn 3.9.0 we can support Unity. @neuecc I know you already know all of this, I’m just curious what features from C# 11/.NET 7 are required. Thanks.
System.Text.Json.Serialization,Newtonsoft.Json
Thank you for the fast fix on my last issue. But when that was solved is stumbled on another edge case with int. I think the problem occurs when deserializing to a primitive type without generics so my best guess is that it is some sort of boxing issue but I failed to narrow it down further. Fortunately the issue can be recreated with the following code
var buff = MemoryPackSerializer.Serialize<int>(0);
var thisWorks = MemoryPackSerializer.Deserialize<int>(buff);
var thisThrows = MemoryPackSerializer.Deserialize( typeof(int), buff);
If this isn't valid code just close the issue, thanks in advance/ Mattias
I think we should force little endian
Like most serializers, it would be nice to have an attribute field specifying the order of that field instead of relying purely on C# member ordering.
[Member(Order=1)]
A plus would be interop with [DataContract], [DataMember]
attributes.
Hi and thanks for your work to provide super-fast serializers for c#.
When testing a migration from MessagePack to MemoryPack I think I stumbled upon a possible bug when serializing a int into IBufferWriter.
I think the trouble is on row 86 in MemoryPackSerializer.Serialize.cs where Advance(span.Length) is called but the span.Length can be much larger than the serialized data since its legal for IBufferWriter.GetSpan() on row 84 to return a larger span than requested.
Hope I'm describing the issue I am seeing well enough /Mattias
First, thanks for updating MemoryPack to work with .NET 7 and AOT.
Unfortunately my native AOT test program (latest .NET 7) is crashing with the error below:
(it works OK in debug and release mode in Visual Studio, but crashes only after publishing and running the AOT executable)
Here is the full test code:
using MemoryPack;
namespace Tests
{
[MemoryPackable]
public partial class MemPackObject
{
public string TestString { get; set; }
}
class MemPackTest
{
static void Main(string[] args)
{
MemPackObject test_object = new MemPackObject();
test_object.TestString = "ABC";
Console.WriteLine("Initial value before serializing: " + test_object.TestString);
byte[] serialized_object = MemoryPackSerializer.Serialize(test_object);
MemPackObject? deserialized_object = MemoryPackSerializer.Deserialize<MemPackObject>(serialized_object);
if (deserialized_object != null)
{
Console.WriteLine("Final value after deserializing: " + deserialized_object.TestString);
}
Console.WriteLine("Test completed. Press any key to exit");
Console.ReadKey();
}
}
}
Hello, this is a pretty good project for dotneters. However, since Net6 is the newest LTS, is there any possibility of adding support for Net6 with the help of other packages? Thanks.
In the readme you explain that we need to add [MemoryPackable]
attribute. I want to avoid this and have clean classes and add such thing via FluentAPI like EF does. Is this already supported or will this be supported?
if u have a member in a MemoryPackable type like this,
public new string Description { get; set; }
u'll get this in generated code:
[global::MemoryPack.Internal.Preserve]
public static void Deserialize(ref MemoryPackReader reader, scoped ref PluginInfo? value)
{
if (!reader.TryReadObjectHeader(out var count))
{
value = default!;
goto END;
}
string __Description;
...
string __Description;
...
}
when work with netstandard2.1, the compiler reports on the generated code:
CS8987 The ‘scoped’ modifier of parameter ‘value’ doesn’t match overridden or implemented member.
how to solve this and get MemoryPack work with netstandard2.1?
since i've already dual-targeted both netstandard2.1 and net7.0, and this compiler error prevents my netstandard2.1 library to be compiled.
partial class Stat
{
[global::MemoryPack.Internal.Preserve]
sealed class StatFormatter : MemoryPackFormatter<Stat>
{
[global::MemoryPack.Internal.Preserve]
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Stat value) <-- here
{
Stat.Serialize(ref writer, ref value);
}
[global::MemoryPack.Internal.Preserve]
public override void Deserialize(ref MemoryPackReader reader, ref Stat value) <-- and here
{
Stat.Deserialize(ref reader, ref value);
}
}
}
Currently compress after ToArray or CopyTo.
But sometimes needs write compressed length to header but current API does not support it(require more copy).
Will be TS realization for use it with Nodejs, e.g.?
Suggested new constructor: [MemoryPackUnion(0, "MyNamespace.MyType, MyAssemblyName")]
this is useful when the implementing type is not in the same assembly with the Interface, which is usually isolated from its implementation and MemoryPackUnionAttribute may not possibly make a reference to it by typeof() operator.
this is a similar measure in:
[Editor("MyNamespace.ByteArrayEditor, MyAssemblyName", "System.Drawing.Design.UITypeEditor, System.Windows.Forms")]
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.