Donald3d:
you no go print before u hang abi na drag and drop you wan do from your system to the wall hehehehehehe

If it's possible, why not?

Craigston:

Ouch! Bjarne Stroustrup wouldn't like that
Yhup. C++ seems be a bag for almost everyone: the farmer, the hunter, the carpenter, the fisherman, ...
But it barely serves some of them while being great for some others.
Have you checked out D (Home - D Programming Language). I might give it a try soon.

Yes, I'm aware of D. We added UFCS to Astro and later found out that D and some other languages use it.

And I actually don't hate C++. I just don't like how I have to keep a lot of wierdness in my brain to command the language successfully. In fact Astro's runtime is written in C++, but we had to replace the interpreter front-end with Python, because we were moving too slow with C++ version.

We probably could use D for the backend, but then D is a managed language, it won't give us the ability to explicitly manage memory resources.

Another language we are currently considering is Rust. For now tho, it's C++ for the runtime, Python for other things.

Donald3d:
*in warri voice* So na all this one you wan print put for wall..... how many square meters be your wall...... shuuuuuuu

Op said hang, not print.
It is an homage to the 99 bottles of beer challenge

Written in Astro

let a, b, c, d, e, f =
    "bottle", "of beer", "on the wall",
    "Take one down and pass it around",
    "no more", "Go to the store and buy some more"

{99:2}
    .each => println "[$1] [a]s [b] [c], [i] [a]s [b].\n[d], [$1-1] [a]s [b] [c]."

println "1 [a] [b] [c], 1 [a] [b].\n[d], [e] [a]s [b] [c]."
println "N[e[2:]] [a]s [b] [c], [e] [a]s [b].\n[f], 99 [a]s [b] [c]."

An event, typically lasting several days, in which a large number of people meet to engage in collaborative computer programming.
- Google

Craigston:
Astro is influenced by languages I like (C++, Python, Julia). I'll be watching that repo.

You are right. Astro is like a nephew to Julia. Astro borrows a good deal of Julia and Python Syntax but it also takes useful concepts from Scala, C#, CLOS, Ruby, Go, Java, etc.

Infact there is a short list of where Astro borrowed certain concepts.

Julia
- Multiple dispatch
- AST Macros
- REPL
- Syntax - '<:', '>:', array Indexing, macros, etc.
- Numeric types
- Math-oriented arrays
- Unicode Identifiers

CLOS 
- Multiple Inheritance

Python
- Syntax - lists, loops, in, etc.

Jai
- Compile-time execution
- Syntax - generics

Ruby
- Block end punctuation

Crystal
- Sophisticated static type inference

Lua
- List/Dict implementation
- Bytecode representation

Go 
- Concurrency model
- Syntax - access modifier blocks, 'func', etc.

Swift's 
- Automatic Reference Counting
- Optionals (Nullables)
- Pattern matching 
- Syntax - where, let, var, etc.

Scala
#- Match functions #
- Constructor types
- Infix notation
- Singletons

Java
- Anonymous types

Javascript
- Unpacking arrays

C#
- Null coalescing 

C++
- Smart pointers
- Pass by value/reference

Notable Mentions
Rust, Kotlin

There are a lot of ideas that went into the design of the language. Some stayed, others were discarded, but we promise not to make Astro a complicated load of incoherent features like C++. But then C++ is a hi-perf systems language, so it has its own value.

Astro goals have been changed several times over the year, cos we don't really have a niche target like most other languages. We just want a nice language that is easy to use and fast to run. But that sounds quite generic, as a result Astro has no concentrated target market. It's in the same camp with Swift. It can be used to write any piece of software, from a website down to an operating system. Of course, you'd need a native compiler implementation of Astro to write an operating system.

As time goes on, we might find the niche we are looking for and stick to that.

-------------------------------------------------------------------------------------

I'm a co-developer of the Astro programming language, originally started by Nypro. Astro language specification has reached version 0.2, but no stable interpreter was written for it until recently due to the constant changes in syntax and semantics of the language.

Now after a year of designing the language, we have managed to come up with an interpreter that is near completion (there are still lots of bugs to fix and changes to make) and as co-developer, I felt we need to start promoting the language.

No production-ready language has made it out of Africa yet, but we hope to stop this unusual trend with the introduction of Astro.

This thread will focus on providing information about Astro until its release.

Astro's concise documentation can be found here. It's actually meant for the developers of the language, but since we don't have a proper documentation yet, it's the only place to get a grasp on how Astro syntax looks. The syntax is, however, not final yet, so we make sure we commit every change as they are made.

Below are planned features and paradigms of the language (some are not yet implemented):
- Procedural
- Object-oriented
- Fast Performance
- First-class Functions (Anonymous Functions, Closures)
- Anonymous Types
- List Comprehension
- Events
- Generators
- Concurrent Coroutines
- Properties
- Expression-oriented
- Optional Typing
- Union Types
- Operator Overloading
- Generics
- Regex
- Exception Handling
- Multiple Inheritance
- Multiple Dispatch
- Unified Function Call Syntax
- Unicode String Support
- Unicode Identifiers
- Algebraic Data Types and Pattern Matching
- Type Inference
- Package Manager
- Meta Programming
- AST Macros
- Automatic Reference Counting (No tracing GC)

Some of these things may not be familiar, but they are actually just big grammars for simple concepts.
Unified Function Syntax Call, for example, simply means being able to use dot notation with ordinary functions.
So

    play(music, 'backwards')

Can be called using its first argument.

    music.play('backwards')

Questions, comments, criticisms and suggestions are welcomed.

Thanks for reading.

UPDATE:
A lot has changed about the language since the time of this post and Astro now adopts sem ver, so the version shown above is now incorrect as of this update. Syntax and implementation details have changed quite a bit too.

asalimpo:
@appcypher
can the dragon book be purchased in nigeria, hard copy? fill me in.

I don't know if you can get a hardcopy in Nigeria, but if you have the means, you can order one from Amazon.

asalimpo:
ok. op, dyu have a mailing list? Wiki and so on.
I was interested or curious about how langs were written earlier on,(and operating systems)
but it seems there's no free resource online. Some said the "dragon book" is the bible
but others say its unreadable. For now to folks like us,it's black magic.
What is required in creating one from scratch, and writing an optimizing compiler for it?
Your team must be unusually motivated, to commit time to this.
Are you guys computer science grads/undergrads. Mathematicians?

You'll need to grow a community around it though, to keep it alive.

The syntax doesnt look friendly at all!! - Man, in this day and age,
cryptic syntax is a minus. Python succeeded ,inspite of its sluggishness cuz it's almost english like.
I think you should work on that. Just my candid observation.

I'm not the op of this thread. I'm thinking of starting another thread instead of hijacking this one.

There are just two people working on this and none of us are CS grads.

As for wiki or mailinglist, we don't have any yet, at least not until we make the interpreter public. And as for books to read, Dragon Book is staple, but it's quite large and can scare one away, i'm still not done with the book yet, I'm not even half way. My lang/compiler experience comes from a mixture of Dragon Book, videos, articles around the internet, scientific papers and experimenting with interpreters.

About the syntax of the language, well I believe the reason you don't find it familiar is because I wrote it in idiomatic Astro. I could have written it in a similar way to Python. Something like this.

type Person:
    let name, age

type Employee <: Person:
    let job, company

func Person(name, age):
    rt new(name, age)

func Employee(name, age, job, company):
    rt new(super(name, age), job, company)

func details(p = Person):
    rt p.name, p.age

func details(e = Employee):
    rt super.details(), e.job, e.company

let john = Person('John Smith', 33)
let tola = Employee('Tola Adeniran', 21, 'App Developer', 'CodeBuzz, Inc.')

println(john.details)
println(tola.details)

Now, compare it with the Python version. The code is now clearer. But Astro is not Python, it has its own way of doing things idiomatically.

And saying the syntax is not friendly is not true. You haven't even learnt Astro to assert that. Even Python has its idiomatic moments where a beginner won't have a clue what's going on. In fact, Astro is not really aimed at beginners.

I believe picking up a new language isn't really meant to be straightforward and as familiar as already known language. You shouldn't expect to find the same syntax everywhere. I wonder what you have to say about Julia, Lisp, Haskell and Scala.

To make the supposedly obfuscated idiomatic Astro code a bit clearer

In Astro:
- type (also class) declaration starts with the keyword 'type'

type Person

- variable declaration starts with the keyword 'let'

let age = 26

- function declaration starts with the keyword 'func'

func add(a, b): 
    rt a + b

- rt means return

- functions return their last expression automatically, so the function above can be reduced to:

func add(a, b): a + b

- brackets surrounding function arguments are optional

add(2, 4) 
add 2, 4

- in Astro, a type that defines its fields in its declaration is called 'constructor type'.
- Such types declare a constructor and their fields at the same time.
- so

type Car(make, model)

- can be expanded to

type Car:
    let make, model

func Car(make, model):
    new(make, model)

mosefin19:
what happen is that i have python installed on my system and have been reading no starch python pdf... thou have been reading so many pdf file earlier but dnt knw hw to go about it... the problem i always have is how to run d code and where is been stored....i also installed geany text editor but try all i could but still getting stuck at some point
any1 who can help a bro here. really hv d determination 2 learn
getting stuck at this early stage can really b frustrating

Join a python group asap

asalimpo:
@appcypher
Congrats. Creating a programming language or compiler is no small undertaking. Eventually, most programmers
want to know how the program that translates their code is made. After all, it's a program, written by humans
, with 1 head and 2 hands. Hope you'll teach the noobs around here and inspire them to your level.
Are u open sourcing it?
Can you share insights with us into how you did it,books you read,tools etc.


But on a serious note, why is africa no where in I.T?
We have professors and phDs in computer science here. Graduates are churned out every year in Cs,
yet in the software space we are no where?
You read online of people who created languages over the weekend! (Python),
Students writing complete working compilers as part of their undergraduate programs, (all good western universities)
and yet in Nigeria, we have just nothing!!!
It's odd.
japan created ruby.
brazil lua.
Africa/nigeria - nadir? ok we dont need to add to the teems of flooded language space but software wise,
computer science wise - we're no where!

A Kenyan dude wrote a scripting lang called Bracescript, but I can't find the source or documentation anywhere, so the credibility of that remains unknown.
Astro is a movement that Africa can also do it. We are making sure that its not just a test language but a language ready for production and yes it will be open-source (which recent language isn't open-source anyway?).
As for experiences, I will share some of them once Astro gets released.
Here is another snippet of Astro / Python code

PYTHON 3
-----------------------------------------------------------------------------

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def details(self):
        return (self.name,  self.age)

class Employee(Person):
    def __init__(self, name, age, job, company):
        super(Employee, self).__init__(name, age)
        self.job = name
        self.company = company

    def details(self):
        return (super(Employee, self).details(), self.job, self.company)

john = Person('John Smith', 33)
tola = Employee('Tola Adeniran', 21, 'App Developer', 'CodeBuzz, Inc.')

print(john.details())
print(tola.details())

ASTRO 0.2
-----------------------------------------------------------------------------

type Person name, age
type Employee {super name, age}, job, company <: Person

func details p=Person: p->name, ->age
func details e=Employee: ...super.details, e->job, ->company

let john = Person 'John Smith', 33
let tola = Employee 'Tola Adeniran', 21, 'App Developer', 'CodeBuzz, Inc.'

println john.details && tola.details

This is not meant to show how concise or terse Astro's source can be, but to show that a statically typed language can also have the same expressiveness and script-feel of a dynamic language, with dynamic language features like duck typing. Astro also keeps the benefits of a static language which include the elimination of certain set of runtime errors that can only be detected with unit tests in dynamic languages. Also as a result of being statically-typed, Astro's interpreter tend to run faster.

The Astro code above is 3 times faster than the Python version, and since Astro is a statically-typed language, this speed factor can grow even more with a JIT or native compiler implementation, but those are undertakings for the future.
WASM is an intermediate representation currently being developed for the web. We believe so much in the connectivity and the ubiquity of the web, so we have plans to make Astro compile to wasm. Then it can join Javascript in its crusade.

Of course, these are all just big talks now, so lets get the proof-of-concept interpreter out first and see where this indigenous language goes.

I'm a co-developer of Pluto(now Astro) and I'm way too excited that I'm so eager to show some of the language syntax.
Astro 0.2's interpreter is near completion and shows promise performance-wise. It's, on average, 2 times faster than Python.
Yes, I know, everything is not about speed. But it's a nice thing to have nonetheless.
I will give a brief description of Astro.
Astro aims to be virtually ubiquitous with various compilation back-end targets like LLVM native, LLVM JIT, wasm, and bytecode interpreters. Its general goal, however, is to be expressive, flexible and fast.
Astro relies heavily on Multiple dispatch and UFCS and consequently merges the divergent worlds of procedural and OOP programming.
You will also find yourself typing idiomatic Astro much more quickly than in Python or Ruby.
Astro type system is sophisticated so much that it feels like dynamic language even though it statically infers all probable types. The type inference is unlike Hindley-Milner techniques seen in Scala or Haskell and comes close to custom type inference algo found in Crystal.


Here are some of the language features, some of which are not finalized or complete and may not make it to 0.2 release
- Optional Typing
- Lexical Scoping
- Generics
- First-class functions (higher-order function, closures, lambdas.)
- Imperative
- Object-oriented
- Procedural
- Expression-oriented
- Operator Overloading
- Multiple Dispatch
- List Comprehension
- Type Inference
- Multiple Dispatch
- Generators
- Coroutines
- Algebraic Data Types & Pattern Matching
- UFCS
- ...

Astro is not really a simple language, and may not be suited for total beginners as much as Python. But once understood, a lot of things will viewed differently and done more concisely. This doesn't mean that the language is hard to grasp. It really isn't.
We are also trying to make sure that the lang doesn't end up looking cryptic like Perl or becoming a load of incoherent baggage that is C++ .

As for why Astro was created when there are dozens of production languages out there, and thousands of other toy languages still in gestation period in respective labs? Well, only Nypro can answer that question properly. For me it's fun, I learnt a lot. I hope it becomes mature enough and joins the group of other rapidly developing languages like Julia and Crystal.

Astro is barely a year old and still under active development.
It will be released to the public under an MIT license very soon.

# Python 3

from sys import stdout
from math import pi
def area():
	while True:
		shape = input("Enter a shape ('sq' for square, 'rec' for rectangle and 'cir' for circle, 'ex' to exit): ".lower().strip()
		if shape == 'rec':
			length = int(input('Enter length: '))
			breadth = int(input('Enter breadth: '))
			drawRec(length, breadth)
			print('\nArea of Rectangle: {}\n\n'.format(length*breadth))
		elif shape == 'sq':
			length = int(input('Enter length: '))
			drawSq(length)
			print('\nArea of Square: {}\n\n'.format(length**2))
		elif shape == 'cir':
			radius = int(input('Enter radius: '))
			print('[Diagram missing]')
			print('\nArea of Circle: {}\n\n'.format(pi * radius**2))
		elif shape == 'ex':
			break
		else:
			print('Gimme the correct input idiot!\n\n')

def drawSq(length):
	print(' ', '_ ' * length)
	for i in range(length):
		print('|', '  ' * length, '\b\b|')
	print('|', '_ ' * length, '|')

def drawRec(length, breadth):
	print(' ', '_ ' * breadth)
	for i in range(length):
		print('|', '  ' * breadth, '\b\b|')
	print('|', '_ ' * breadth, '\b\b|')

area()

-----------------------------------------------------------------------------------
# Astro 0.2

func area:
	loop:
		let shape = {scanln "Enter a shape ('sq' for square, 'rec' for rectangle"
			"and 'cir' for circle, 'ex' to exit): "}.toLower.trim
		match shape
		with 'rec':
			let length, breadth = Int scanln 'Enter length: ', && scanln 'Enter breadth: '
			drawRec length, breadth
			println '\nArea of Rectangle: [length * breadth]\n\n'
		with 'sq':
			let length = Int scanln 'Enter length: '
			drawSq length
			println '\nArea of Square: [length^2]\n\n'
		with 'cir':
			let radius = Int scanln 'Enter radius: '
			println '\[Diagram missing]' && '\nArea of Circle: [pi * radius^2]\n\n'
		with 'ex': break
		with: println 'Gimme the correct input stupid!\n\n'
	..
..

func drawSq length:
	println sp, '_ ' * length
	for i in length: println '|', sp * length, '\b\b|'
	println '|', '_ ' * length, '\b\b|'
..

func drawRec length, breadth:
	println sp, '_ ' * breadth
	for i in length: println '|', sp * breadth, '\b\b|'
	println '|', '_ ' * breadth, '\b\b|'
..

area

Astro:
println 'Hello, World!'

during my survey here programmers only focus on frontend and forget about the backend.

Then ur survey is flawed. I do see a lot of back end topics here. Maybe not many, but they are not scarce.

i notice we are good but not professionals in business

This is a forum for discussion, you will see different personalities in a forum. A serious client should be reviewing a dev's portfolio, not how he called another person a chicken in a language war. Arguments happen all the time. Not just here in NL, but in foreign forums too. If someone's outburst is what a client is checking for, I don't think such client is serious about finding a dev.

If the group link doesn't work. Throw ur number here and I will add you up.
I will try to always update the link tho.

You are a Python newbie, perhaps an expert. Hop in here let's discuss python. Except this time you will be meeting the other Java devs. Java folks are equally welcomed to this group.
Dynamic language meets static language. We can learn sth from each other. We can even reduce the rift between both language by living together. Making crossing from one language to the other easy. You can move from creating ur next android app (java) to developing a client's website (python). We don't have to hate each other. Both languages have sth to offer.
Web dev:
Python:
- Django
- Flask
- Pyramid
Java:
- Java EE apis
Desktop app dev:
Python:
- PyQT
Java:
- JavaFx
- Swing
Mobile app dev:
Python:
- Kivy
Java:
- Android
Mobile app dev
Game dev:
Python:
- Pygame
- Unity(boo)
Java:
- Libgdx
- Jogl
Scientific dev:
Python:
- Numpy
- SciPy
- Anaconda
Java:
- JScience
- EJML

If you only know other languages, you are also welcome. Javascript, Julia, R, C, C++, Crystal, C#, Ruby, Haskell, Rust, Go, Fortran, BASIC(gerrarahia), Ada(??we might need to check ur age), lisp, erlang, D, Swift developers. We are all the same family.
Sorry if I didn't mention ur fave lang. Just hop on the bus and let's ride together.

One thing tho, for the newbies, this is not a tutoring group, but we'll sure guide you towards becoming better.

If I sound fishy, maybe I am, maybe I'm not, who knows.

GROUP LINK: chat.whatsapp..com/2neanjfKUPPGNHnOvGncfXb

Let's create something beautiful, shall we?

noibilism:
Many people think that due to the arrival of newer programming languages like ruby, mean stack, python, lua, etc. PHP’s popularity is diminishing slowly. In this article, we will discuss whether or not PHP language is dying with the help of statistics because stats don’t tell lie!!!/

Erm... but Python, Ruby, Lua are older than PHP, except maybe Ruby which was released the same year.

asalimpo:
php - so ubiquitous. It's everywhere. But most experts say it was poorly designed.
python, ruby are supposedly better designed than php but in popularity, php just leads.

lisp - light years ahead of so many languages of its time yet, it never became popular?
Went nowhere in the mainstream, despite efforts by many fans to popularise it

oop - inferior to functional programming , by the experts, yet it dominated the industry.


scala, clojure - i cant seem to find anything negative said of this languages online
yet, the've not chipped a dent in the popularity of the language
they were supposed to steal mindshare from-java.

c++ - one confusing bloated, overcomplex language that is hard to learn and almost impossible to master-
this language dominated the 80s and 90s and still dominates certain industries!
C - same as c++.

Perl - a language with no set principle on how to get things done. There's more than one (obscure) way to do anything. This language dominated the web scene for many years until a brainchild, with the same philosophy was born - php. Php followed in perl's footsteps of being inconsistent.

PHP codebase might be larger (mostly due to legacy code), but it is definitely not more popular than python.
I bet if PHP wasn't improving its syntax and consistencies, ppl will just drop it for better alternatives. PHP7 introduced more consistencies to the language.
Apart from C++ which is a truly complicated language and still used in niche areas like game dev, I don't see how worst is better.

I nominate myself appcypher

*sighs*

BL3zzY:
the design bad die.
op go seek solution to ur site
stop giving urself hope

The sites's problem is not one dimensional at all. Not only is it slow, it pushes a pop-up at you that you have no option of rejecting.
WTF! Na by force to login or sign up.

Random Guy in the Block.

XketchDesigns:



Just like every software i learnt, it all happened under a month.
it all depends on determination and resources.

6 hours a day on youtube of one month, you will do something much better than that. i programme to, if you are lazy speak for your self and not others.

Bla..bla....bla.
Create yours in 1 month.

alezzy13:


must you quote the whole post?

I was about to say that too. Their brains are quarter of what they are supposed to be.

XketchDesigns:
2016 almost 2017 with brick graphics..
this is something anybody can do with one month of learning java or python programming.
however, it is nice to have something with the local content, we must step up our game to be at where the major countries in the world are.
this just makes me think of what the might have showed mark zuckerberg when he was in nigeria, the guy will just be laughing in his mind, looking and be like seriously??

Oh Oh, I would love to see you create something close to that after 1 month of learning Java or Python.
Even if you create just a moving car without the environment, I will applaud you.
Bloody civilians! Dem no sabi how to program, just to dey yarn gibberish.

As for the game developer, I will tell him to look into shader development. His 3D models are not bad looking. But he needs to work more on the look of the materials, so they can look more realistic.
Adding atmospherics like lens flare, fogs, goes a long way to improve the graphics. Chromatic abberation, skid marks. Lots of other improvements can be done.
I will like to share the little I know about shaders to make this game look better. That is if you are using Unity game engine.
Good luck!

.

I understand ur enthusiasm. Shutting down the internet for everybody else doesn't make sense. Internet is what makes the world a global village.

dueal:


Just so we are clear on d quadratic(3cv) and cubic(4cv) bezier curves.

Also, you won't need skeletal systems for d environment,thats 4 characters or waving trees. Like I said and propose, UbiSoft used vector graphics techniques for their 2d skeletal system so does Spine. If you paid any attention to my point you'd notice I mention tesselation, separate parts, vertices, curves, UVs. All what Spine uses are vector-graphics techniques. The images are UV textured on those vertices.

I believe the back-to-back started with; To use sprites or not to use sprites.

I admit I was mixing up cubic and quad bezier.
If by vector graphics you mean using UVs, then that's exactly what my app is doing. UVs are the coords on a texture. Textures are not scalable, they show their flaws when you zoom on them too much. Why? because they use raster images. And that's what I've been saying all along.
I use Spine. The images it allows are raster images. What it does, for a simple workflow, is use the images as texture to a quad, this is called texture mapping. And it passes that to the GPU to be rendered to the display.

dueal:


You talk tech i'll give that to you. But quadratic bezier means restrictions to 3-control vertices and conic-shapes and not flexible as cubic curves(4-cv), update on that and it's still within the realm of vector-graphics techniques.

As I presumed, your implementation is similar to say the analogy of what game biped xters were in the PS1 era of disjointed parts with transformations. If your aim was to make as flexible a skeletal system as dat used by UbiSoft, well it's still crude.

Also, you are not restricted to using vertex colors and have a mono-shade on ur character...you can use UV's.

If you have used Illustrator/inkscape, you will notice, while creating a vector image, that each curve is provided with two handles. This allows for S-shaped curves. That's quadratic (has 4 control points). Even though a vector format can use cubic beziers (which I find easier to use BTW), they simply don't though. ai, svg, eps all use quad bezier.
UbiArt is doing exactly what my app is going to do. They might have used vector graphics for some aspects, but the lush environments were texture (i.e. raster) based.
Using raster images doesn't mean the animations have to be rigid or robotic. They can be deformed. All it takes is increasing the vertex count near areas of the texture where deformation will happen. So squash and stretch animation with an image is very possible.
Check this interesting Spine FFD tutorial.

https://www.youtube.com/watch?v=0Dd2M8XBTo0
And I can bet my last kobo that the mobile version of Rayman Jungle uses texture-based animations throughout. Vector-based animations are just too expensive to be throwing about on mobile.

dueal:


There seems to be some confusion here. I am basing these arguments on what you intend to do I.e 2d skeletal system.

Yes, 2 tris equals a quad, but that isn't enough to model a humanoid character with a skeletal system. From what I get from ur point of view you are assuming hardware accelerated vector-graphics. I mean vector-graphics techniques, some which will not be needed.

Take for instance, the hand of a biped character. The one place u need cubic-bezier curves will be at the elbow. The rest is just a polygon, u can also run the animation in gpu via shaders and still have parallelism. This is the natural way. Gpu's see ur simple mesh and you do what u want with dat. Cubic Beziers are cheap even when you want to subdivide to get something the gpu can use(lines/tris).

The way you explain ur system it seems like you draw one character in png then position joints/bones and animate that. What do you run interpolation on to animate the xter? Texels? On which processor, CPU or GPU?

I think I get what you are trying to say. The way you explained how a human biped will be created makes me assume that you are mixing stuffs up. In that case you are not talking about vector-graphics (and they don't use cubic beziers BTW. It's quadratic), you mean the use of just vertices and vertex colors to create a character. Even though they are scalable, the problem with that proposition is that you won't have as much details as a texture can provide. All those pixel-level details cannot be created with vertices. That will just be plain expensive.
Let me just give you a simple breakdown of how the 2d skeletal system is supposed to work.
- You import a series of raster images that make up the movable parts of your character.
- You draw out bone gizmos on each image.
- You control (rotate, translate or scale) the bone gizmos and use that to animate the images.
- The series of animations are saved in a file.
- The images are packed in a texture atlas.
- Each image becomes a texture to a quad. And using the animation provided, each image is animated as appropriate.
For a simple workflow like this, the vertex animation can be done on GPU. But its not always this simple.
And using only vertex colors instead of textures might work for some low-detailed elements in the game. It is however not a replacement for textures.
This is not just me coming up with stuffs. This how other 2D skeletal animation apps implement it.