Would a plugin that made use of something like GitPython work? A user would probably still need a github login, but if it could download an “unstable” part library with the github comments, display the part and allow easy editing and commits this may be less of a barrier than currently exists. Thoughts/suggestions anyone?
1 Like
I do not agree with the boldness of this statement, @hermit, but perhaps I am not disillusioned enough yet
“Unfortunately, AFAIK, no software provides large, usable, good-quality library. You need to built every freaking component from scratch, a fact that often slowly sinks in as every beginner hopes to get libraries but get slowly disillusioned.”
I am using the kicad libraries from git. They are moving. A lot has changed in the past few months. From time to time that is a burden, but it is a consequence of my choice to use the latest stuff.
I guess ones impression of lib quality depends on what it is one is doing and which kind of parts one is using. Yes, there are parts that are not in the libs, but in my experience it is not the majority. I have made some of the more complicated parts that were missing and donated them to the libraries. It is a community effort, after all, and I am part of the community.
1 Like
That is the reason the strict quality control should remain in place.
I like the idea @NMNC introduced for a ‘pending library’, but I fear it will grow very fast to the point that no-one has the guts to finish other people’s mess.
Then some people will start using the ‘good enough’ parts from the pending.lib and in a years time we will be back to square one: A whole bunch of non-complient parts and four poor maintainers that are finishing the work that others couldn’t be bothered about. That must be very frustrating.
7 Likes
+1
The progress could be slower in increasing the library parts, but surely more robust and reliable.
The same has been done for the new 3D parts library, and the result is a fantastic (IMO) ready to go 3D mechanical and rendering library for ECAD that I consider the best available around!
4 Likes
My personal take on all of this is that building and maintaining good libraries is a huge asset to KiCAD but it is also a lot of work. The parts I created were hard work to make, get them to comply and into the libraries.
I have accepted that. It will not become any easier if we want to create parts that anyone can use.
We all appreciate using parts that others have made and this is largely due to the fact that there is some level of standardization in naming, orientation, numbering etc.etc., despite the efforts manufacturers seem to be making to obscure things (for instance by using their company specific designations for housings).
As a consequence, creating a part for your own use is different from creating a part that you want to share. If you are creating something to share, it must conform to guidelines we have learned to appreciate so much when we use someone else’s efforts.
Let’s accept that and get on with it.
I do not want to degrade this conversation in any way, because it is useful to discuss how we want to endorse which guideline. I merely want to point out that, whatever standard or guideline is chosen, it will always be hard work that requires a lot of attention to details.
8 Likes
If you want to talk about the “good old days” (formerly known as “these difficult times”) . . . . take a poll to locate Forum members who laid out boards with tape on mylar. Often at 2:1 scale factor, then photographed and reduced to true size. Libraries? Well, you had stick-on patterns for 8-pin, 14-pin, and 16-pin DIP packages; TO-3, TO-5, TO-220 and TO-92 transistors. And the layout tape was black - using red and blue tapes for the two layers wasn’t yet common.
But nostalgia just ain’t what it used to be!
Dale
Thank God for Bishop Graphics. You did the design with colored pencils and then taped over the lines.
John Eaton
Haha, yes I remember those days. I did the tape and mylar also until I “upgraded” to a plotter with etching ink. What a disaster that was, never got it quite right. I made a simple sound sampler for the Amiga which turned out to be pretty popular during social commodore gatherings (i.e. copy parties). So I sold a bunch of these samplers almost every meeting. Although drilling holes in a PCB has some therapeutic character, doing 40 a week or so was a bit too therapeutic for me so I made a rig allowing me to drill 5 boards at the time. I sniffed up so much PCB dust, leaded smoke and board acid, its a wonder I am still here.
Now to send off gerbers and get boards back in the mail is magic, I enjoy it every time I get them back in.
I was even thinking that a simple Wordpress form or a Google Forms submission page where you could upload a library entry ± footprint ± 3dmodel step/wrl (along with the datasheet and screenshots) and a script to process them might work… But I accept that that is not a complete ‘toolset that already exists’. And as far as superior to the current system that is also, I guess, depending on who’s perspective. For those comfortable and happy with Git it will not be a significant improvement, but anything to ease the submission mechanism might encourage those who aspire to help to put their shoulder to the collective wheel would, in my mind be a help.
I have been thinking about a tool that removes the need to attach screenshots to each submission. The python scripts could render the symbols or footprints and then perhaps upload to Imgur or similar.
But the following problems would need to be solved:
- Create a set of rendering scripts for symbols and footprints
- Work out where to store the images (AFAIK you can’t attach an image to a GitHub discussion via API)
- Comment on the discussion with a link to the screenshots.
It’d be awesome if the rendering scripts could also highlight any KLC errors too…
If anyone has any knowledge on how to achieve these points, fire away 
1 Like
KiCad can render to SVG, and SVG can be displayed in a browser.
imgur, however, cannot host SVG files (I just tried it).
There are a few services that might, but I haven’t used any of them.
Here’s an attached svg file:
Yes but KiCad cannot be installed and run on the Travis server. We would be limited to simpler scripting tools such as Python etc.
1 Like
Oh, KiCad other than pcbnew, isn’t scriptable. So this would be outside of KiCad. With that, we could use external rendering, but it would duplicate much of the rendering within kicad.
Ideally, we could extract images from KiCad itself.
How about something like this:
https://pypi.python.org/pypi/svgwrite/
SVG seems like a very good rendering model for this use since it’s vector based instead of raster.
Edit: But it’s also a “simple” text based format. So would be possible to create from scratch, no external library needed.
To be clear:
Our scripts run on the travis-ci servers, which spin up a new virtual environment each build. KiCad software is not installed and so.the scripts would need to download and install KiCad each time. This is something I think we do not want to pursue.
Duplicating rendering effort in Python shouldn’t be too hard* and allows us to do cool stuff like circling pins that have errors…
* I have almost got rendering working for symbols. Footprints will be similar amount of work but probably more as I want to be able to highlight certain layers to show errors etc.
I’m using python and pycairo for rendering
1 Like
Apparently GitHub Gists can be used to share SVGs… (Not sure how circular this argument might become if at least one of the the aims is to get away from Git!)
1 Like
Can I propose something “radical” for the library stuff folks? I too like the idea of a relatively easily accessible holding pen for new parts but as reported earlier in the discussion, (too) many contributors often submit ‘good-enough-for-me’ parts. I’d suggest to add an “Obsolete” repo in addition to the “Pending” repo, and use it in the following way:
After a user submits a part, it is stored in the proposed “Pending” repo. Normal submission rules apply and our intrepid Librarians do their chosen job. If said part is not fully compliant to be included outright, and the aforementioned Librarian comments on the part to make it so, the user submitting the part has a 3 month window to fix it, following the date of the comment. If no or insufficient action has been taken during this period, the part is moved to the “Obsolete” repo. In this repo the part is only visible for the user and Librarians, other users have no access to it. This means it cannot be used in new designs. The “Obsolete” repo also has a time limit: after 9 months the part is permanently removed. During this period (in total one year from day of submission) the user can work on the part to improve/fix compliance and request a revaluation by a Librarian before the allowed time runs out and the part disappears into the digital shredder. (note: one could read “obsolete” as “I-don’t-give-a-fsck” 
But that might be a bit harsh)
Having said that, an external tool to assist contributors to submit their new parts (libraries, footprints, 3D models optional) could be used to ease the burden on using Git for non-coders (like me) and at the same time offer functionality to check parts prior to submission for compliance should reduce the number of ‘good-enough’ submissions. The tool could (would/should*) give the PuT (part-under-test) a grade, reflecting the measure of compliance. This grade can then be used by the Librarians to determine which part to check/comment on/include on the basis of a higher compliance number meaning less work for them to allow the part into the stable/production repo. For obvious reasons said grade cannot be tampered with by the user submitting the part. 
*encircle as appropriate 
Your thoughts?
1 Like
Everything you describe here does already exist. The pending repo is the pull request itself.
There are scripts for locally checking contributions. (the same scripts that are run automatically for each pull request.)
Closed pull requests could be seen as the obsolete repo.
1 Like
The pending lib as suggested would allow other users to step in and help; the pull request does not. There is a difference @Rene_Poschl, or am I overlooking something?
Another thought for @Dutch_Master: For my parts, we had a small but useful discussion about in which lib the part should be stored when done. For many parts it is obvious, but for some parts that could fall into different categories.
This can be done in the pull request, as usual. I would not like to loose the information or discussion on the definitive lib when a part is in the pending lib.
And, finally, a thought about git. I appreciate some users have difficulties when trying to use git. However, it does exactly what it is supposed to do. I believe it is the right tool for the job. The job of maintaining information and allowing many people to change it in a controlled manner, is not easy. We can discuss tools at length, but in the end I believe that if we were to change tools, the job at hand would not make it any easier. It is a complicated subject and will remain complicated.
By the way, the first time I added a part to the libs, I followed the instructions (almost) to the letter. They were really helpful.
How to contribute to libraries
On git (instructions for Mac, Windows and Linux):
How to fork a repository
How to sync a repository
And for good measure, here are the guidelines:
Library Convention
4 Likes
Fair enough Gents, I’m not overly familiar with the procedure. A GUI would simplify things for most contributors though, I’m not aware of an already existing one? (but that’s probably me missing something!)
1 Like